Sustainable Transport Planning

Functionality and data access tools for transport planning, including origin-destination analysis, route allocation and modelling travel patterns.

stplanr is a package for sustainable transport planning with R.

It provides functions for solving common problems in transport planning and modelling, such as how to best get from point A to point B. The overall aim is to provide a reproducible, transparent and accessible toolkit to help people better understand transport systems and inform policy.

The initial work on the project was funded by the Department of Transport (DfT) as part of the development of the Propensity to Cycle Tool (PCT). The PCT uses origin-destination data as the basis of spatial analysis and modelling work to identify where bicycle paths are most needed. See the package vignette (e.g. via vignette("introducing-stplanr")) or an academic paper on the Propensity to Cycle Tool (PCT) for more information on how it can be used. This README gives some basics.

stplanr should be useful to researchers everywhere. The function route_graphhopper(), for example, works anywhere in the world using the graphhopper routing API and read_table_builder() reads-in Australian data. We welcome contributions that make transport research easier worldwide.

Data frames representing flows between origins and destinations must be combined with geo-referenced zones or points to generate meaningful analyses and visualisations of 'flows' or origin-destination (OD) data. stplanr facilitates this with od2line(), which takes flow and geographical data as inputs and outputs a SpatialLinesDataFrame. Some example data is provided in the package:

data(cents, flow)

Let's take a look at this data:

flow[1:3, 1:3] # typical form of flow data
#> 920573         E02002361         E02002361 109
#> 920575         E02002361         E02002363  38
#> 920578         E02002361         E02002367  10
cents[1:3,] # points representing origins and destinations
#> class       : SpatialPointsDataFrame 
#> features    : 3 
#> extent      : -1.546463, -1.511861, 53.8041, 53.81161  (xmin, xmax, ymin, ymax)
#> coord. ref. : +init=epsg:4326 +proj=longlat +datum=WGS84 +no_defs +ellps=WGS84 +towgs84=0,0,0 
#> variables   : 4
#> names       :  geo_code,  MSOA11NM, percent_fem,  avslope 
#> min values  : E02002382, Leeds 053,    0.408759, 2.284782 
#> max values  : E02002393, Leeds 064,    0.458721, 2.856563

These datasets can be combined as follows:

travel_network <- od2line(flow = flow, zones = cents)
w <- flow$All / max(flow$All) *10
plot(travel_network, lwd = w)

The package can also allocate flows to the road network, for example through a link to the API.

Route functions take lat/lon inputs:

trip <-
  route_cyclestreet(from = c(-1, 53), to = c(-1.1, 53), plan = "balanced")

and place names, found using the Google Map API:

if(!Sys.getenv("CYCLESTREET") == ""){
  trip <- route_cyclestreet("Bradford", "Leeds", plan = "balanced")

We can replicate this call to multiple times using line2route.

intrazone <- travel_network$Area.of.residence == travel_network$Area.of.workplace
travel_network <- travel_network[!intrazone,]
if(Sys.getenv("CYCLESTREET") == ""){
  t_routes = routes_fast
} else {
  t_routes <- line2route(travel_network)

Another way to visualise this is with the leaflet package:

leaflet() %>% addTiles() %>% addPolylines(data = t_routes)

For more examples, example("line2route").

overline is a function which takes a series of route-allocated lines, splits them into unique segments and aggregates the values of overlapping lines. This can represent where there will be most traffic on the transport system, as illustrated below.

t_routes$All <- travel_network$All
rnet <- overline(sldf = t_routes, attrib = "All", fun = sum)
lwd <- rnet$All / mean(rnet$All)
plot(rnet, lwd = lwd)

To install the stable version, use:


The development version can be installed using devtools:

# install.packages("devtools") # if not already installed

stplanr depends on rgdal, which can be tricky to install.

On Ubuntu rgdal can be installed with:

sudo apt-get install r-cran-rgdal

Using apt-get ensures the system dependencies, such as gdal are also installed.

On Mac, homebrew can install gdal. Full instructions are provided here.

The current list of available functions can be seen with:

lsf.str("package:stplanr", all = TRUE)

To get internal help on a specific function, use the standard way.


stplanr has many dependencies. These are designed to help make it fast, but may make it slow to install for the first time.

Its dependencies are plotted below using the minCRAN package:

dg <- miniCRAN::makeDepGraph("stplanr")

  • Please report issues, feature requests and questions to the github issue tracker
  • License: MIT
  • Get citation information for stplanr in R doing citation(package = 'stplanr')
  • This project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.


stplanr 0.1.7

  • There is a new vignette! See vignettes/stplanr-paper.Rmd and vignette("stplanr-paper") for details.
  • The original introducing-stplanr vignette has been updated. It now provides a more basic introduction for people new to R for spatial and transport data.
  • line2route() has been refactored to improve error detection and allow n_processes arguments. Thanks @nikolai-b. See pull/151 for details.
  • line_match() function added, a wrapper around rgeos::gDistance(), to find similar routes.
  • RCurl and data.table dependencies have been removed
  • New functions od_aggregate() and sp_aggregate() have been added, to enable OD data to be aggregated to new geographic levels.
  • #141 fixed: viaroute() works again.
  • #153 fixed: bidirectional = TRUE returns a different result in line_bearing() now.
  • A new branch that uses sf is being tested. We may eventually transition to using simple features classes instead of sp classes.

stplanr 0.1.6

  • onewayid() is now a generic function, meaning it can handle spatial and non-spatial data
  • New arguments provided for line2route() allow you to specify variables to join-by - also has updated and more sensible defaults
  • New function od_id_order() to put origin-destination ids in order, to identify 2 way duplicates (split out from onewayid())
  • See the issue tracker
  • Bug in route_cyclestreet() leading change_elev and av_incline being wrong now fixed
  • Bug making variable names with spaces in the id columns failed - now fixed #138


  • New argument destinations added to od2line(). See example(od2line) for an example.
  • New dataset destinations for showing how OD matrix with destinations can be converted to spatial data
  • New argument list_output allows the route information to be saved as a list, allowing save_raw = TRUE (which does not return a Spatial object) to be passed to the route_ function.
  • tmap dependency removed for faster installs


  • Bug with line2route() (#124) fixed
  • Various improvements to documentation


  • New function reproject() is a simple wrapper around spTransform() that uses crs_select_aeq() to convert a spatial object in geographic (lat/lon) coordinates into on with projected coordinates, with units of 1 m. This is useful for various spatial operations, such as finding the length and area of an object.

  • Implement gprojected(), a function for performing GIS operations on a temporary, projected, version of spatial objects.

  • Addition of line_bearing() to return the bearing of lines based on start and end points.

  • Addition of angle_diff() for finding the angular difference between lines: are they roughly parallel or perpendicular?


  • line2df() now works on lines with multiple vertices and is faster.

  • Fixes in the examples used to illustrate how od_dist() works.


  • Update to OSRM functions to support API v5.

  • New parameter byvars in the overline() function, to allow disaggregation of results by a grouping variable (see example(overline)).

  • Faster implementation of od2line(): od2line2(). Plan is to replace the original if no issues are found with new implementation.

  • New function od2odf() which converts OD data into a dataframe of origins and destinations (feeds od2line2() but also useful as self-standing function).

  • New argument new_proj in buff_geo() allows the results to be exported to any coordinate reference system (CRS).

  • New function gprojected() generalises concept of buff_geo(), building on crs_select_aeq() to allow any GIS query to be conducted on a temporary projected version of spatial objects with geographical CRSs.

  • New function od_dist() can quickly calculate Euclidean distances of OD pairs without converting to spatial objects.


  • Bug fix in onewayid() so it captures all lines.

  • Various improvements to documentation and code.


  • Interface to the Google Distance Matrix API with dist_google.

  • New transport planning API added, with route_transportapi_public (for testing).

  • Update to line2route, allowing it to accept different routing funtions via the new argument route_fun (for testing - tested with route_fun = route_cyclestreet).

  • New functions for creating origin-destination data frames (point2odf) and SpatialLinesDataFrames (points2flow).

  • Addition of n_vertices and is_linepoint for identifying the number of vertices in spatial objects and whether the 'line' is really a point.


  • line2route refactored, with 10 fold speed increases on large (1000+) batches of lines.


  • Addition of new class definition SpatialLinesNetwork, methods for plot and summary and functions calc_network_routes and find_network_nodes allowing fast route calculations via igraph and other network analysis functions.

  • Functions for removing beginning and end of lines: toptail and toptailgs. Helper functions buff_geo, crs_select_aeq and line2points added.

  • Functionality for reading in the UK's stats19 data: read_stats19_* functions download, unzip and re-categorise the data.

  • read_table functions added for reading Australian OD data.

  • decode_gl added to decode Google polylines and other functions for querying and reading data from OSRM services.

  • gtfs2sldf added to import GTFS routes as SpatialLinesDataFrames.

  • Published on CRAN

Reference manual

It appears you don't have a PDF plugin for this browser. You can click here to download the reference manual.


0.1.7-3 by Robin Lovelace, 2 months ago

Report a bug at

Browse source code at

Authors: Robin Lovelace [aut, cre], Richard Ellison [aut], Barry Rowlingson [ctb] (Author of overline), Nick Bearman [ctb] (Co-author of gclip), Malcolm Morgan [ctb] (Co-author of angle_diff), Nikolai Berkoff [ctb] (Co-author of line2route)

Documentation:   PDF Manual  

Task views: Analysis of Spatial Data

MIT + file LICENSE license

Imports jsonlite, maptools, raster, rgdal, rgeos, dplyr, RgoogleMaps, openxlsx, methods, httr, R.utils, stringi, stringr, readr, lubridate, geosphere, Rcpp, igraph, nabor, foreach, doParallel

Depends on sp

Suggests testthat, knitr, rmarkdown, tmap, tmaptools, OpenStreetMap, leaflet

Linking to RcppArmadillo, Rcpp

System requirements: GNU make

See at CRAN