Skip to content

Latest commit

 

History

History
138 lines (100 loc) · 3.99 KB

README.md

File metadata and controls

138 lines (100 loc) · 3.99 KB
Raw
    ____  _______  ___________  ____  ____ ______
   / __ \/ ___/ / / / ___/ __ \/ __ \/ __ `/ ___/
  / /_/ (__  ) /_/ / /__/ /_/ / /_/ / /_/ / /
 / .___/____/\__, /\___/\____/ .___/\__, /_/
/_/         /____/          /_/    /____/

PyPI PyPI - License PyPI - Python Version

psycopgr is a Python wrapper of pgRouting with one purpose:

Computing routes on real map for humans.

Tested with

  • Python 3.6.5
  • PostgreSQL 11.2
  • PostGIS 2.5.2
  • pgRouting 2.6.2
  • osm2pgrouting 2.3.6

Preparation

  • Install PostgreSQL, PostGIS, and pgRouting
  • Create database to store map data
  • Import OpenStreet map data into database

A step by step note can be found here.

Installation

pip install psycopgr

or

pipenv install psycopgr

Routing with Python!

First, create an PGRouting instance with database connection. Arguments are same as that psycopg2.connect() takes.

from psycopgr import PgrNode, PGRouting
pgr = PGRouting(dbname='mydb', user='user', password='secret',
                host='localhost', port='5432')

Adjust meta datas of tables including the edge table properies if they are different from the default (only the different properties needs to be set), e.g.:

pgr.set_meta_data(cost='cost_s', reverse_cost='reverse_cost_s', directed=true)

This is the default meta data:

{
    'table': 'ways',
    'id': 'gid',
    'source': 'source',
    'target': 'target',
    'cost': 'cost_s', # driving time in second
    'reverse_cost': 'reverse_cost_s', # reverse driving time in second
    'x1': 'x1',
    'y1': 'y1',
    'x2': 'x2',
    'y2': 'y2',
    'geometry': 'the_geom',
    'has_reverse_cost': True,
    'directed': True,
    'srid': 4326
}

Nodes are points on map which are represented by PgrNode namedtuple with geographic coordinates (longitude and latitude) rather than vague vertex id (vid) in the tables. PgrNodes is defined as:

PgrNode = namedtuple('PgrNode', ['id', 'lon', 'lat'])

in which id could be None or self-defined value, and lon and lat are double precision values.

For example:

nodes = [PgrNode(None, 116.30150, 40.05500),
         PgrNode(None, 116.36577, 40.00253),
         PgrNode(None, 116.30560, 39.95458),
         PgrNode(None, 116.46806, 39.99857)]

Now we can do routings! This is really straightforward:

# many-to-many
routings = pgr.get_routes(nodes, nodes, end_speed=5.0, pgx_file='r.pgx')
# one-to-one
routings = pgr.get_routes(nodes[0], nodes[1])
# one-to-many
routings = pgr.get_routes(nodes[0], nodes)
# many-to-one
routings = pgr.get_routes(nodes, node[2])
  • end_speed: speed from node to nearest vertices on ways in unit km/h.
  • gpx_file: set it to output paths to a gpx file.

The returned is a dict of dict: {(start_node, end_node): {'path': [PgrNode], 'cost': cost}

By default, cost is traveling time along the path in unit second. It depends on the means of columns of the edge table that you set as cost and reverse_cost. You can assign the relations by set_meta_data function.

We can also get only costs without detailed paths returned:

costs = pgr.get_costs(nodes, nodes)

The returned is also a dict: {(start_node, end_node): cost}

Low-level wrapper of pgRouting functions

psycopgr function pgRouting function
dijkstra pgr_dijkstra
dijkstra_cost pgr_dijkstraCost
astar pgr_astar

These are direct wrappings of pgRouting functions. For example, dijkstra takes vertex ids as input. This list may be extended in the future.

Tutorial

Here is a tutorial.