Openrouteservice

https://openrouteservice.org/
Admin
Openrouteservice is a free and open-source platform providing a variety of Geo-services through a...
Tokens:25,991
Snippets:303
Trust Score:9.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install and Use openrouteservice R Package

Source: https://openrouteservice.org/openrouteservice-r-package

Install the package from GitHub and use it to find routes between two locations. Requires an API key. Visualizes the route using leaflet.

```R
library("openrouteservice")

# one-time API key set-up
# ors_api_key("<your-api-key>")

# query for coordinates
locations <- lapply(c("Heidelberg", "Kraków"), ors_geocode)
coordinates <- lapply(locations, function(x) x$features[[1]]$geometry$coordinates)

# find route 
route <- ors_directions(coordinates, format="geojson")

# route length in kilometres and duration in hours
unlist(route$features[[1]]$properties$summary) / c(1000, 3600)
##    distance    duration 
## 1051.861300    9.205167

# draw on map using leaflet
library(leaflet)

leaflet() %>%
  addTiles() %>%
  addGeoJSON(route, fill=FALSE) %>%
  fitBBox(route$bbox)
```

--------------------------------

### Install openrouteservice-r Package

Source: https://openrouteservice.org/author/aoles

Install the latest version of the openrouteservice R package directly from GitHub using the devtools package. Ensure devtools is installed first.

```r
devtools::install_github("GIScience/openrouteservice-r")
```

--------------------------------

### Visualize Start and Destination Points

Source: https://openrouteservice.org/example-avoid-flooded-areas-with-ors

Adds markers to the map for the start and destination coordinates. Ensure coordinates are in [longitude, latitude] format.

```python
coordinates = [[11.653361, 52.144116], [11.62847, 52.1303]]  # Central Station and Fire Department
for coord in coordinates:
    folium.map.Marker(list(reversed(coord))).add_to(map_tweet)
```

--------------------------------

### Import Libraries for Route Optimization

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

Imports Folium for map visualization and Shapely for geometric operations. Ensure these libraries are installed in your environment.

```python
import folium
from shapely import wkt, geometry
```

--------------------------------

### Import necessary libraries for routing optimization

Source: https://openrouteservice.org/disaster-optimization

Imports required libraries for mapping, data manipulation, and the openrouteservice API. Ensure you have these installed and an API key configured.

```python
import folium
from folium.plugins import BeautifyIcon
import pandas as pd
import openrouteservice as ors

```

--------------------------------

### Filter and Count Smoker Pubs

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

This example demonstrates how to filter places to find 'smoker' bars and then count them. It requires the 'ors' object to be initialized.

```python
query['filters_custom'] = {'smoking': ['yes']}  # Filter out smoker bars
pubs_smoker = ors.places(**query)['features']

print("\nAmount of smoker pubs: {}".format(len(pubs_smoker)))
```

--------------------------------

### Visualize delivery locations and depot on a map

Source: https://openrouteservice.org/disaster-optimization

Loads delivery site data from a CSV and plots markers on a Folium map. The depot location is also marked. This helps visualize the logistics setup before optimization.

```python
# First define the map centered around Beira
m = folium.Map(location=[-18.63680, 34.79430], tiles='cartodbpositron', zoom_start=8)

# Next load the delivery locations from CSV file at ../resources/data/idai_health_sites.csv
# ID, Lat, Lon, Open_From, Open_To, Needed_Amount
deliveries_data = pd.read_csv(
    '../resources/data/idai_health_sites.csv',
    index_col="ID",
    parse_dates=["Open_From", "Open_To"]
)

# Plot the locations on the map with more info in the ToolTip
for location in deliveries_data.itertuples():
    tooltip = folium.map.Tooltip("<h4><b>ID {}</b></p><p>Supplies needed: <b>{}</b></p>".format(
        location.Index, location.Needed_Amount
    ))

    folium.Marker(
        location=[location.Lat, location.Lon],
        tooltip=tooltip,
        icon=BeautifyIcon(
            icon_shape='marker',
            number=int(location.Index),
            spin=True,
            text_color='red',
            background_color="#FFF",
            inner_icon_style="font-size:12px;padding-top:-5px;"
        )
    ).add_to(m)

# The vehicles are all located at the port of Beira
depot = [-19.818474, 34.835447]

folium.Marker(
    location=depot,
    icon=folium.Icon(color="green", icon="bus", prefix='fa'),
    setZIndexOffset=1000
).add_to(m)

m

```

--------------------------------

### Example POI Response for Kindergarten

Source: https://openrouteservice.org/example-apartment-search-with-ors

This is an example of the GeoJSON response received from the openrouteservice API when querying for 'kindergarten' POIs within a specific geographic area. It includes features with geometry and properties like OSM ID, distance, and category information.

```json
{
  "type": "FeatureCollection",
  "bbox": [-122.42795, 37.782774, -122.42795, 37.782774],
  "features": [{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.42795, 37.782774]
    },
    "properties": {
      "osm_id": 256908810,
      "osm_type": 2,
      "distance": 0.0,
      "category_ids": {
        "153": {
          "category_name": "kindergarten",
          "category_group": "education"
        }
      },
      "osm_tags": {
        "name": "Golden Gate Kindergarten"
      }
    }
  }],
  "information": {
    "attribution": "openrouteservice.org | OpenStreetMap contributors",
    "version": "0.1",
    "timestamp": 1637671278,
    "query": {
      "request": "pois",
      "filters": {
        "category_ids": [153]
      },
      "geometry": {
        "geojson": {
          "coordinates": [[[-122.445337, 37.792922], [-122.444881, 37.789351], [-122.444081, 37.788552], [-122.44151, 37.787075], [-122.438726, 37.785497], [-122.436451, 37.784382], [-122.433286, 37.782666], [-122.428048, 37.781626], [-122.42782, 37.781654], [-122.426023, 37.782688], [-122.424703, 37.783627], [-122.423604, 37.784552], [-122.422552, 37.785645], [-122.419664, 37.788801], [-122.418643, 37.789984], [-122.417421, 37.79178], [-122.416677, 37.792939], [-122.416171, 37.793954], [-122.416212, 37.796162], [-122.416249, 37.796211], [-122.419151, 37.797964], [-122.423673, 37.800414], [-122.427709, 37.80268], [-122.429929, 37.803611], [-122.433147, 37.803505], [-122.433598, 37.803392], [-122.436389, 37.802618], [-122.438463, 37.800448], [-122.441391, 37.797205], [-122.442385, 37.796121], [-122.445337, 37.792922]]],
          "type": "Polygon"
        }
      },
      "sortby": "distance"
    }
  }
}

```

--------------------------------

### GET /v2/directions/{profile}

Source: https://openrouteservice.org/dev

Retrieves routing directions for a specified profile.

```APIDOC
## GET /v2/directions/{profile}

### Description
Retrieves routing directions for a specified profile.

### Method
GET

### Endpoint
/v2/directions/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The routing profile to use.
```

--------------------------------

### GET /v2/directions/{profile}

Source: https://openrouteservice.org/dev

Retrieves a basic route between two points for a specified profile in GeoJSON format.

```APIDOC
## GET /v2/directions/{profile}

### Description
Get a basic route between two points with the profile provided. Returned response is in GeoJSON format.

### Method
GET

### Endpoint
/v2/directions/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport profile to use for routing.
```

--------------------------------

### Import Libraries for Geospatial Analysis and ORS

Source: https://openrouteservice.org/example-avoid-flooded-areas-with-ors

Imports necessary Python libraries for geospatial data handling, mapping, and interacting with the openrouteservice client. Ensure all dependencies are installed.

```python
import folium

from openrouteservice import client

import fiona as fn
from shapely.geometry import Polygon, mapping, MultiPolygon, LineString, Point
from shapely.ops import cascaded_union

import pyproj

```

--------------------------------

### Example POI Response for Supermarket

Source: https://openrouteservice.org/example-apartment-search-with-ors

This GeoJSON response illustrates the results of a query for 'supermarket' POIs. It lists multiple supermarket features with their respective geometries, distances, and relevant OSM tags such as name, website, and opening hours.

```json
{
  "type": "FeatureCollection",
  "bbox": [-122.43527, 37.782711, -122.418255, 37.797229],
  "features": [{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.431464, 37.782711]
    },
    "properties": {
      "osm_id": 219058165,
      "osm_type": 2,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "name": "Safeway 0995",
        "website": "https://local.safeway.com/ca/san-francisco-995.html",
        "opening_hours": "06:00-24:00"
      }
    }
  },{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.434504, 37.78854]
    },
    "properties": {
      "osm_id": 263224863,
      "osm_type": 2,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "phone": "415-567-4902",
        "wheelchair": "yes",
        "name": "Mollie Stone's"
      }
    }
  },{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.423414, 37.79009]
    },
    "properties": {
      "osm_id": 1002186270,
      "osm_type": 1,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "phone": "+1 415 674 0500",
        "name": "Whole Foods Market"
      }
    }
  },{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.421707, 37.796547]
    },
    "properties": {
      "osm_id": 1478520948,
      "osm_type": 1,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "opening_hours": "8:00-21:00",
        "website": "www.realfoodco.com",
        "name": "Real Food Company"
      }
    }
  },{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.431032, 37.785255]
    },
    "properties": {
      "osm_id": 2184767720,
      "osm_type": 1,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "name": "Nijiya Market",
        "wheelchair": "yes",
        "phone": "(415) 563-1901"
      }
    }
  },{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.420783, 37.790205]
    },
    "properties": {
      "osm_id": 2698387925,
      "osm_type": 1,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "name": "Golden Veggie Market",
        "phone": "(415) 771-9099",
        "wheelchair": "yes"
      }
    }
  },{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.418255, 37.794474]
    },
    "properties": {
      "osm_id": 4637210183,
      "osm_type": 1,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "name": "J H Grocery and Liquor"
      }
    }
  },{
    "type": "Feature",
    "geometry": {
      "type": "Point",
      "coordinates": [-122.43527, 37.797229]
    },
    "properties": {
      "osm_id": 8140177640,
      "osm_type": 1,
      "distance": 0.0,
      "category_ids": {
        "518": {
          "category_name": "supermarket",
          "category_group": "shops"
        }
      },
      "osm_tags": {
        "name": "Luke's"
      }
    }
  }]
}

```

--------------------------------

### Initialize ORS client

Source: https://openrouteservice.org/centrality-analysis-using-export-endpoint

Create an instance of the ORS client using the previously defined API key to facilitate API communication.

```python
ors_client = ors.Client(key=api_key)
```

--------------------------------

### GET point elevation

Source: https://openrouteservice.org/dev

Retrieve elevation for a single 2D point using a GET request.

```bash
  # GET point
  curl -XGET https://localhost:5000/elevation/point?geometry=13.349762,38.11295
```

--------------------------------

### Import necessary modules

Source: https://openrouteservice.org/centrality-analysis-using-export-endpoint

Load the required libraries for openrouteservice interaction, GeoJSON processing, visualization, and network analysis.

```python
import openrouteservice as ors
import geojson
import folium
import networkx as nx
from branca.colormap import linear
from folium import plugins
```

--------------------------------

### Import necessary libraries

Source: https://openrouteservice.org/example-avoid-obstacles-while-routing

Import all required libraries for the project, including folium for mapping, pyproj for coordinate transformations, requests for API calls, and openrouteservice client.

```python
import folium
import pyproj
import requests
from openrouteservice import client
from shapely import geometry
from shapely.geometry import Point, LineString, Polygon, MultiPolygon
```

--------------------------------

### GET /geocode/search

Source: https://openrouteservice.org/dev

Performs a geocoding search.

```APIDOC
## GET /geocode/search

### Description
Performs a geocoding search.

### Method
GET

### Endpoint
/geocode/search
```

--------------------------------

### Initialize client and process construction sites

Source: https://openrouteservice.org/example-avoid-obstacles-while-routing

Sets up the openrouteservice client with an API key, fetches construction site data from a URL, and visualizes these sites as buffered polygons on a Folium map. It iterates through the data, creates markers for each site, and adds a 10-meter radius buffer polygon around each point. The coordinates are reversed for compatibility with Folium/Leaflet.

```python
# Set up the fundamentals
api_key = 'your_key'  # Individual api key
ors = client.Client(key=api_key)  # Create client with api key
rostock_json = requests.get(url).json()  # Get data as JSON

map_params = {'tiles': 'Stamen Toner',
              'location': ([54.13207, 12.101612]),
              'zoom_start': 12}
map1 = folium.Map(**map_params)

# Populate a construction site buffer polygon list
sites_poly = []
for site_data in rostock_json['features']:
    site_coords = site_data['geometry']['coordinates']
    folium.features.Marker(list(reversed(site_coords)),
                           popup='Construction point<br>{0}'.format(site_coords)).add_to(map1)

    # Create buffer polygons around construction sites with 10 m radius and low resolution
    site_poly_coords = create_buffer_polygon(site_coords,
                                             resolution=2,  # low resolution to keep polygons lean
                                             radius=10)
    sites_poly.append(site_poly_coords)

    site_poly_coords = [(y, x) for x, y in site_poly_coords]  # Reverse coords for folium/Leaflet
    folium.vector_layers.Polygon(locations=site_poly_coords,
                                 color='#ffd699',
                                 fill_color='#ffd699',
                                 fill_opacity=0.2,
                                 weight=3).add_to(map1)

map1
```

--------------------------------

### GET /geocode/reverse

Source: https://openrouteservice.org/dev

Reverse Geocode Service that resolves coordinates to an address.

```APIDOC
## GET /geocode/reverse

### Description
Returns the next enclosing object with an address tag which surrounds the given coordinate.

### Method
GET

### Endpoint
/geocode/reverse
```

--------------------------------

### Perform Optimization Request and Visualize Results

Source: https://openrouteservice.org/disaster-optimization

Initializes the openrouteservice client, sends an optimization request with defined jobs and vehicles, and visualizes the resulting routes on a map using Folium. Route geometries are decoded from polylines.

```python
# Initialize a client and make the request
ors_client = ors.Client(key='your_key')  # Get an API key from https://openrouteservice.org/dev/#/signup
result = ors_client.optimization(
    jobs=deliveries,
    vehicles=vehicles,
    geometry=True
)

# Add the output to the map
for color, route in zip(['green', 'red', 'blue'], result['routes']):
    decoded = ors.convert.decode_polyline(route['geometry'])  # Route geometry is encoded
    gj = folium.GeoJson(
        name='Vehicle {}'.format(route['vehicle']),
        data={"type": "FeatureCollection", "features": [{"type": "Feature",
                                                         "geometry": decoded,
                                                         "properties": {"color": color}
                                                         }]},
        style_function=lambda x: {"color": x['properties']['color']}
    )
    gj.add_child(folium.Tooltip(
        """<h4>Vehicle {vehicle}</h4>
        <b>Distance</b> {distance} m <br>
        <b>Duration</b> {duration} secs
        """.format(**route)
    ))
    gj.add_to(m)

folium.LayerControl().add_to(m)
m
```

--------------------------------

### GET /geocode/search/structured

Source: https://openrouteservice.org/dev

Structured Forward Geocode Service (beta) for refined search inputs.

```APIDOC
## GET /geocode/search/structured

### Description
Returns a JSON formatted list of objects corresponding to the search input using a structured format.

### Method
GET

### Endpoint
/geocode/search/structured
```

--------------------------------

### GET /geocode/autocomplete

Source: https://openrouteservice.org/dev

Geocode Autocomplete Service that provides asynchronous responses for search inputs.

```APIDOC
## GET /geocode/autocomplete

### Description
Returns a JSON formatted list of objects corresponding to the search input. Requests should be throttled and responses are asynchronous.

### Method
GET

### Endpoint
/geocode/autocomplete
```

--------------------------------

### Import openrouteservice Client and Folium

Source: https://openrouteservice.org/example-apartment-search-with-ors

Import necessary libraries for using the openrouteservice client and creating maps with Folium.

```python
import folium

from openrouteservice import client
```

--------------------------------

### Construct a NetworkX DiGraph

Source: https://openrouteservice.org/centrality-analysis-using-export-endpoint

Initializes a directed graph and populates it with edges from the response data.

```python
g = nx.DiGraph()

for edge in resp['edges']:
    g.add_edge(edge['fromId'], edge['toId'], weight=edge['weight'])
```

--------------------------------

### GET /elevation/point

Source: https://openrouteservice.org/dev

Enriches a 2D point with elevation data using query parameters.

```APIDOC
## GET /elevation/point

### Description
This endpoint takes a 2D point and enriches it with elevation from a variety of datasets.

### Method
GET

### Endpoint
/elevation/point

### Parameters
#### Query Parameters
- **geometry** (string) - Required - The 2D point coordinates (e.g., 13.349762,38.11295)
```

--------------------------------

### Define Vehicles for Optimization

Source: https://openrouteservice.org/disaster-optimization

Sets up a list of vehicles with their IDs, start/end locations, capacities, and operational time windows. Time windows are expressed as POSIX timestamps.

```python
# Define the vehicles
# https://openrouteservice-py.readthedocs.io/en/latest/openrouteservice.html#openrouteservice.optimization.Vehicle
vehicles = list()
for idx in range(3):
    vehicles.append(
        ors.optimization.Vehicle(
            id=idx,
            start=list(reversed(depot)),
            # end=list(reversed(depot)),
            capacity=[300],
            time_window=[1553241600, 1553284800]  # Fri 8-20:00, expressed in POSIX timestamp
        )
    )
```

--------------------------------

### GET /geocode/search

Source: https://openrouteservice.org/dev

Forward Geocode Service that returns a JSON formatted list of objects corresponding to the search input.

```APIDOC
## GET /geocode/search

### Description
Returns a JSON formatted list of objects corresponding to the search input. Boundary parameters can be combined if they are overlapping.

### Method
GET

### Endpoint
/geocode/search
```

--------------------------------

### Calculate Routes from Apartments to POIs

Source: https://openrouteservice.org/example-apartment-search-with-ors

Calculates and visualizes walking routes from each apartment to all its associated POIs. It records the duration of each route and adds markers for POIs on a map. Requires 'ors' client and 'folium' library.

```python
# Set up common request parameters
params_route = {'profile': 'foot-walking',
                'format_out': 'geojson',
                'geometry': 'true',
                'format': 'geojson',
                'instructions': 'false',
                }

# Set up dict for font-awesome
style_dict = {'kindergarten': 'child',
              'supermarket': 'shopping-cart',
              'hairdresser': 'scissors'
              }

# Store all routes from all apartments to POIs
for apt in apartments.values():
    for cat, pois in apt['categories'].items():
        pois['durations'] = []
        for poi in pois['geojson']:
            poi_coords = poi['geometry']['coordinates']

            # Perform actual request
            params_route['coordinates'] = [apt['location'],
                                           poi_coords
                                           ]
            json_route = ors.directions(**params_route)

            folium.features.GeoJson(json_route).add_to(map1)
            folium.map.Marker(list(reversed(poi_coords)),
                              icon=folium.Icon(color='white',
                                               icon_color='#1a1aff',
                                               icon=style_dict[cat],
                                               prefix='fa'
                                               )
                              ).add_to(map1)

            poi_duration = json_route['features'][0]['properties']['summary']['duration']
            pois['durations'].append(poi_duration)  # Record durations of routes

map1
```

--------------------------------

### Initialize Openrouteservice Client

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

Initializes the openrouteservice client with the provided API key. This client object is used to make requests to the openrouteservice API.

```python
from openrouteservice import client, places

ors = client.Client(key=api_key)
```

--------------------------------

### Define Export Parameters

Source: https://openrouteservice.org/centrality-analysis-using-export-endpoint

Sets the routing profile and the bounding box coordinates for the area of interest.

```python
profile = "driving-car"
#bbox = [[8.677139,49.412872],[8.690443,49.421080]] # Neuenheim
#bbox = [[8.655967,49.382834],[8.718537,49.435273]] # Heidelberg
bbox = [[8.668069,49.398477],[8.697079,49.426174]] # Neuenheim + Bergheim + Weststadt
```

--------------------------------

### POST /v2/directions/{profile}

Source: https://openrouteservice.org/dev

Returns a route between two or more locations for a selected profile and its settings as JSON.

```APIDOC
## POST /v2/directions/{profile}

### Description
Returns a route between two or more locations for a selected profile and its settings as JSON.

### Method
POST

### Endpoint
/v2/directions/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport profile to use for routing.
```

--------------------------------

### Get Pub Addresses and Add to Map

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

This snippet iterates through a list of smoker pubs, retrieves their names using the geocoding API, and adds markers to a Folium map. Note the rate limit for geocoding calls.

```python
pubs_addresses = []

for feat in pubs_smoker:
    lon, lat = feat['geometry']['coordinates']
    name = ors.pelias_reverse(point=(lon, lat))['features'][0]['properties']['name']
    popup = "<strong>{0}</strong><br>Lat: {1:.3f}<br>Long: {2:.3f}".format(name, lat, lon)
    icon = folium.map.Icon(color='lightgray',
                           icon_color='#b5231a',
                           icon='beer',  # fetches font-awesome.io symbols
                           prefix='fa')
    folium.map.Marker([lat, lon], icon=icon, popup=popup).add_to(m)
    pubs_addresses.append(name)
```

--------------------------------

### Create Map and Request Normal Route

Source: https://openrouteservice.org/example-avoid-obstacles-while-routing

Initializes a map and requests a normal driving route between two points, excluding construction sites. The route is then added to the map.

```python
map_params = {'location': ([54.091389, 12.096686]),
                   'zoom_start': 13}
map2 = folium.Map(**map_params)

request_params = {'coordinates': [[12.108259, 54.081919],
                                  [12.072063, 54.103684]],
                  'format_out': 'geojson',
                  'profile': 'driving-car',
                  'preference': 'shortest',
                  'instructions': 'false'}
route_normal = ors.directions(**request_params)
folium.features.GeoJson(data=route_normal,
                        name='Route without construction sites',
                        style_function=style_function('#FF0000'),
                        overlay=True).add_to(map2)
```

--------------------------------

### Calculate and Display Regular Route

Source: https://openrouteservice.org/dieselgate-avoid-berlin-banned-diesel-streets

Calculates and displays a standard driving route between two points in Berlin using the openrouteservice API. It also sets up a Folium map and adds markers for the start and end points.

```python
# Basic parameters
api_key = 'your_key'  # https://openrouteservice.org/sign-up
ors = client.Client(key=api_key)

map_berlin = folium.Map(tiles='https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
                        attr='&copy; <a href="https://openstreetmap.org/copyright">OpenStreetMap contributors</a>',
                        location=([52.516586, 13.381047]),
                        zoom_start=13.5)  # Create map

popup_route = "<h4>{0} route</h4><hr>" \
              "<strong>Duration: </strong>{1:.1f} mins<br>" \
              "<strong>Distance: </strong>{2:.3f} km"

# Request route
coordinates = [[13.372582, 52.520295], [13.391476, 52.508856]]
direction_params = {'coordinates': coordinates,
                    'profile': 'driving-car',
                    'format_out': 'geojson',
                    'preference': 'shortest',
                    'geometry': 'true'}

regular_route = ors.directions(**direction_params)  # Direction request

# Build popup
distance, duration = regular_route['features'][0]['properties']['summary'].values()
popup = folium.map.Popup(popup_route.format('Regular',
                                            duration / 60,
                                            distance / 1000))

gj = folium.GeoJson(regular_route,
                    name='Regular Route',
                    style_function=style_function('blue')) \
    .add_child(popup) \
    .add_to(map_berlin)

folium.Marker(list(reversed(coordinates[0])), popup='Bundeskanzleramt').add_to(map_berlin)
folium.Marker(list(reversed(coordinates[1])), popup='Deutsches Currywurst Museum').add_to(map_berlin)
map_berlin
```

--------------------------------

### Initialize ORS Client and Define Data Path

Source: https://openrouteservice.org/example-avoid-flooded-areas-with-ors

Initializes the openrouteservice client with your API key and specifies the path to the tweet data shapefile. Replace 'YOUR-KEY' with your actual ORS API key.

```python
# insert your ORS api key
api_key = 'YOUR-KEY'
ors = client.Client(key=api_key)

# Twitter data from 2013
tweet_file = 'tweets/tweets_magdeburg.shp'

```

--------------------------------

### Visualize Routes with Folium

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

Visualizes both a 'random' route and an optimized route on a map using the Folium library. This snippet demonstrates how to add GeoJSON data with custom styling to a Folium map. Ensure Folium and Openrouteservice are installed.

```python
def style_function(color):
    return lambda feature: dict(color=color,
                                weight=3,
                                opacity=1)


# See what a 'random' tour would have been
pubs_coords.append(pubs_coords[0])
request = {'coordinates': pubs_coords,
           'profile': 'driving-car',
           'geometry': 'true',
           'format_out': 'geojson',
           #            'instructions': 'false'
           }
random_route = ors.directions(**request)

folium.features.GeoJson(data=random_route,
                        name='Random Bar Crawl',
                        style_function=style_function('#84e184'),
                        overlay=True).add_to(m)

```

--------------------------------

### POST /v2/snap/{profile}

Source: https://openrouteservice.org/dev/#/api-docs

Snaps coordinates to the road network and returns a list of points.

```APIDOC
## POST /v2/snap/{profile}

### Description
Returns a list of points snapped to the nearest edge in the routing graph. In case an appropriate snapping point cannot be found within the specified search radius, “null” is returned.

### Method
POST

### Endpoint
/v2/snap/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The routing profile to use.
```

--------------------------------

### Calculate Distance Matrix with Openrouteservice

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

Calculates the travel durations between multiple locations using the Openrouteservice Matrix API. Ensure you have the 'openrouteservice' library installed and configured with your API key. This is useful for scenarios where you need to know the travel time between all pairs of points before optimizing a route.

```python
from openrouteservice import distance_matrix

pubs_coords = [feat['geometry']['coordinates'] for feat in pubs_smoker]

request = {'locations': pubs_coords,
           'profile': 'driving-car',
           'metrics': ['duration']}

pubs_matrix = ors.distance_matrix(**request)
print("Calculated {}x{} routes.".format(len(pubs_matrix['durations']), len(pubs_matrix['durations'][0])))

```

--------------------------------

### Iterate and Fetch POIs by Category

Source: https://openrouteservice.org/example-apartment-search-with-ors

This script iterates through predefined apartment data and fetches Points of Interest (POIs) for specific categories like 'kindergarten', 'supermarket', and 'hairdresser' within the apartment's geographic bounds. It prints the count of POIs found for each category.

```python
categories_poi = {'kindergarten': [153],
                  'supermarket': [518],
                  'hairdresser': [395]}

for name, apt in apartments.items():
    apt['categories'] = dict()  # Store in pois dict for easier retrieval
    params_poi['geojson'] = apt['iso']['features'][0]['geometry']
    print("\n{} apartment".format(name))

    for typ, category in categories_poi.items():
        params_poi['filter_category_ids'] = category
        apt['categories'][typ] = dict()
        apt['categories'][typ]['geojson'] = ors.places(**params_poi)['features']  # Actual POI request
        print(f"	{typ}: {len(apt['categories'][typ]['geojson'])}")
```

--------------------------------

### Solve Traveling Salesperson Problem with OR-Tools

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

Optimizes a route by solving the Traveling Salesperson Problem (TSP) using Google's OR-Tools library. This snippet takes a pre-calculated distance matrix and finds the shortest path visiting all locations. It requires the 'ortools' library to be installed. Note the adaptation for OR-Tools versions 7.0 and above.

```python
from ortools.constraint_solver import pywrapcp

tsp_size = len(pubs_addresses)
num_routes = 1
start = 0  # arbitrary start location
coords_aoi = [(y, x) for x, y in aoi_coords]  # swap (x,y) to (y,x)

optimal_coords = []

if tsp_size > 0:

    # Old Stuff kept for reference
    # routing = pywrapcp.RoutingModel(tsp_size, num_routes, start)

    # New Way according to ortools v7.0 docs (https://developers.google.com/optimization/support/release_notes#announcing-the-release-of-or-tools-v70)
    # manager = pywrapcp.RoutingIndexManager(num_locations, num_vehicles, depot)
    # routing = pywrapcp.RoutingModel(manager)

    # Adaption according to old and new way
    manager = pywrapcp.RoutingIndexManager(tsp_size, num_routes, start)
    routing = pywrapcp.RoutingModel(manager)


    # Create the distance callback, which takes two arguments (the from and to node indices)
    # and returns the distance between these nodes.
    def distance_callback(from_index, to_index):
        """Returns the distance between the two nodes."""
        # Convert from routing variable Index to distance matrix NodeIndex.
        from_node = manager.IndexToNode(from_index)
        to_node = manager.IndexToNode(to_index)
        return int(pubs_matrix['durations'][from_node][to_node])


    # Since v7.0, this also needs to be wrapped:
    transit_callback_index = routing.RegisterTransitCallback(distance_callback)

    routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
    # Solve, returns a solution if any.
    assignment = routing.Solve()
    if assignment:
        # Total cost of the 'optimal' solution.
        print("Total duration: " + str(round(assignment.ObjectiveValue(), 3) / 60) + " minutes\n")
        index = routing.Start(start)  # Index of the variable for the starting node.
        route = ''
        # while not routing.IsEnd(index):
        for node in range(routing.nodes()):
            # IndexToNode has been moved from the RoutingModel to the RoutingIndexManager
            optimal_coords.append(pubs_coords[manager.IndexToNode(index)])
            route += str(pubs_addresses[manager.IndexToNode(index)]) + ' -> '
            index = assignment.Value(routing.NextVar(index))
        route += str(pubs_addresses[manager.IndexToNode(index)])
        optimal_coords.append(pubs_coords[manager.IndexToNode(index)])
        print("Route:\n" + route)

```

--------------------------------

### POST /v2/directions/{profile}/json

Source: https://openrouteservice.org/dev

Returns a route between two or more locations for a selected profile and its settings as JSON.

```APIDOC
## POST /v2/directions/{profile}/json

### Description
Returns a route between two or more locations for a selected profile and its settings as JSON.

### Method
POST

### Endpoint
/v2/directions/{profile}/json

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport profile to use for routing.
```

--------------------------------

### Import Libraries and Define Style Function

Source: https://openrouteservice.org/dieselgate-avoid-berlin-banned-diesel-streets

Imports necessary libraries and defines a function to style map data. This is a prerequisite for creating visualizations.

```python
from openrouteservice import client
import folium
from shapely.geometry import LineString, mapping
from shapely.ops import cascaded_union


def style_function(color):
    return lambda feature: dict(color=color,
                                opacity=0.5,
                                weight=4,
                                )
```

--------------------------------

### POST /v2/export/{profile}

Source: https://openrouteservice.org/dev

Exports the base graph for a selected profile as a list of points, edges, and weights within a bounding box.

```APIDOC
## POST /v2/export/{profile}

### Description
Returns a list of points, edges and weights within a given bounding box for a selected profile as JSON.

### Method
POST

### Endpoint
/v2/export/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport mode profile.
```

--------------------------------

### POST /v2/directions/{profile}/gpx

Source: https://openrouteservice.org/dev

Returns a route between two or more locations for a selected profile and its settings as GPX.

```APIDOC
## POST /v2/directions/{profile}/gpx

### Description
Returns a route between two or more locations for a selected profile and its settings as GPX.

### Method
POST

### Endpoint
/v2/directions/{profile}/gpx

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport profile to use for routing.
```

--------------------------------

### Display Map

Source: https://openrouteservice.org/example-avoid-flooded-areas-with-ors

Renders the map object, which includes all added markers, routes, and controls.

```python
map_tweet
```

--------------------------------

### POST /v2/matrix/{profile}

Source: https://openrouteservice.org/dev

Generates duration or distance matrices for multiple source and destination points.

```APIDOC
## POST /v2/matrix/{profile}

### Description
Returns duration or distance matrix for multiple source and destination points. By default a square duration matrix is returned.

### Method
POST

### Endpoint
/v2/matrix/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport mode profile.
```

--------------------------------

### Generate Apartment Isochrones and Visualize on Map

Source: https://openrouteservice.org/example-apartment-search-with-ors

This snippet generates 15-minute walking isochrones for multiple apartment locations and adds them to a Folium map. Ensure you replace 'your_key' with your actual openrouteservice API key. The 'range' parameter is in seconds, so 900 seconds equals 15 minutes.

```python
api_key = 'your_key'  # Provide your personal API key
ors = client.Client(key=api_key)
# Set up folium map
map1 = folium.Map(tiles='Stamen Toner', location=([37.738684, -122.450523]), zoom_start=12)

# Set up the apartment dictionary with real coordinates
apartments = {'first': {'location': [-122.430954, 37.792965]},
              'second': {'location': [-122.501636, 37.748653]},
              'third': {'location': [-122.446629, 37.736928]}
              }

# Request of isochrones with 15 minute on foot.
params_iso = {'profile': 'foot-walking',
              'range': [900],  # 900/60 = 15 minutes
              'attributes': ['total_pop']  # Get population count for isochrones
              }

for name, apt in apartments.items():
    params_iso['locations'] = [apt['location']]  # Add apartment coords to request parameters
    apt['iso'] = ors.isochrones(**params_iso)  # Perform isochrone request
    folium.features.GeoJson(apt['iso']).add_to(map1)  # Add GeoJson to map

    folium.map.Marker(list(reversed(apt['location'])),  # reverse coords due to weird folium lat/lon syntax
                      icon=folium.Icon(color='lightgray',
                                       icon_color='#cc0000',
                                       icon='home',
                                       prefix='fa',
                                       ),
                      popup=name,
                      ).add_to(map1)  # Add apartment locations to map

map1
```

--------------------------------

### Buffer Route and Identify Intersecting Sites

Source: https://openrouteservice.org/example-avoid-obstacles-while-routing

Creates a buffer around the calculated route and identifies construction sites that fall within this buffer. The buffer and markers for intersecting sites are added to the map.

```python
route_buffer = LineString(route_normal['features'][0]['geometry']['coordinates']).buffer(0.009)
folium.features.GeoJson(data=geometry.mapping(route_buffer),
                        name='Route Buffer',
                        style_function=style_function('#FFFF00'),
                        overlay=True).add_to(map2)

sites_buffer_poly = []
for site_poly in sites_poly:
    poly = Polygon(site_poly)
    if route_buffer.intersects(poly):
        folium.features.Marker(list(reversed(poly.centroid.coords[0]))).add_to(map2)
        sites_buffer_poly.append(poly)
```

--------------------------------

### Create and Display Regular Route

Source: https://openrouteservice.org/example-avoid-flooded-areas-with-ors

Generates a standard route without any avoided areas. This route is then added to the map as a GeoJson layer.

```python
avoided_point_list = []  # Create empty list with avoided tweets
route_directions = CreateRoute(avoided_point_list)  # Create regular route with still empty avoided_point_list

folium.features.GeoJson(data=route_directions,
                        name='Regular Route',
                        style_function=style_function('#ff5050'),
                        overlay=True).add_to(map_tweet)
print('Generated regular route.')
```

--------------------------------

### POST /v2/matrix/{profile}

Source: https://openrouteservice.org/dev

Calculates a distance/duration matrix for a specified profile.

```APIDOC
## POST /v2/matrix/{profile}

### Description
Calculates a distance/duration matrix for a specified profile.

### Method
POST

### Endpoint
/v2/matrix/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The routing profile to use.
```

--------------------------------

### Calculate and Print Route Durations

Source: https://openrouteservice.org/example-optimize-pub-crawl-with-ors

Calculates the duration of both optimal and random routes in minutes and prints them. Ensure that `optimal_route` and `random_route` objects are populated before execution.

```python
optimal_duration = 0
random_duration = 0

optimal_duration = optimal_route['features'][0]['properties']['summary']['duration'] / 60
random_duration = random_route['features'][0]['properties']['summary']['duration'] / 60

print("Duration optimal route: {0:.3f} mins\nDuration random route: {1:.3f} mins".format(optimal_duration,
                                                                                         random_duration))
```

--------------------------------

### POST /v2/isochrones/{profile}

Source: https://openrouteservice.org/dev

Calculates isochrones for a specified profile.

```APIDOC
## POST /v2/isochrones/{profile}

### Description
Calculates isochrones for a specified profile.

### Method
POST

### Endpoint
/v2/isochrones/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The routing profile to use.
```

--------------------------------

### POST /v2/isochrones/{profile}

Source: https://openrouteservice.org/dev

Calculates reachability areas based on time or distance for given locations.

```APIDOC
## POST /v2/isochrones/{profile}

### Description
The Isochrone Service supports time and distance analyses for one single or multiple locations. You may specify the isochrone interval or provide multiple exact isochrone range values.

### Method
POST

### Endpoint
/v2/isochrones/{profile}

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport mode profile.
```

--------------------------------

### Define Common POI Request Parameters

Source: https://openrouteservice.org/example-apartment-search-with-ors

Sets up common parameters for Point of Interest (POI) requests, sorting results by distance.

```python
# Common request parameters
params_poi = {'request': 'pois',
              'sortby': 'distance'}

# POI categories according to
```

--------------------------------

### POST /v2/export/{profile}/topojson

Source: https://openrouteservice.org/dev

Exports the base graph topology for a selected profile.

```APIDOC
## POST /v2/export/{profile}/topojson

### Description
Returns a list of edges, edge properties, and their topology within a given bounding box for a selected profile.

### Method
POST

### Endpoint
/v2/export/{profile}/topojson

### Parameters
#### Path Parameters
- **profile** (string) - Required - The transport mode profile.
```

--------------------------------

### POST /v2/snap/{profile}

Source: https://openrouteservice.org/dev

Snaps coordinates to the nearest edge in the routing graph.

```APIDOC
## POST /v2/snap/{profile}

### Description
Returns a list of points snapped to the nearest edge in the routing graph. In case an appropriate snapping point cannot be found within the specified search radius, “null” is returned.

### Method
POST

### Endpoint
/v2/snap/{profile}
```

--------------------------------

### Process Vehicle 1 Station Data

Source: https://openrouteservice.org/disaster-optimization

Loads station data for Vehicle 1, converts arrival and departure times from seconds to datetime objects, and displays the resulting DataFrame. Requires the pandas library.

```python
df_stations_1 = pd.DataFrame(stations[1], columns=["Station ID", "Arrival", "Departure"])
df_stations_1['Arrival'] = pd.to_datetime(df_stations_1['Arrival'], unit='s')
df_stations_1['Departure'] = pd.to_datetime(df_stations_1['Departure'], unit='s')
df_stations_1
```

--------------------------------

### POST /optimization

Source: https://openrouteservice.org/dev

Solves vehicle routing optimization problems.

```APIDOC
## POST /optimization

### Description
Solves vehicle routing optimization problems.

### Method
POST

### Endpoint
/optimization
```
Tokens:
Raw