org.opentripplanner.streets

Class StreetLayer

java.lang.Object

org.opentripplanner.streets.StreetLayer

All Implemented Interfaces:

Serializable

public class StreetLayer
extends Object
implements Serializable

This stores the street layer of OTP routing data. Is is currently using a column store. An advantage of disk-backing this (FSTStructs, MapDB optimized for zero-based integer keys) would be that we can remove any logic about loading/unloading graphs. We could route over a whole continent without using much memory. Any data that's not used by Analyst workers (street names and geometries for example) should be optional so we can have fast-loading, small transportation network files to pass around. It can even be loaded from the OSM MapDB on demand. There's also https://github.com/RichardWarburton/slab which seems simpler to use. TODO Morton-code-sort vertices, then sort edges by from-vertex.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
EdgeStore	edgeStore
TransitLayer	linkedTransitLayer
static int	MIN_SUBGRAPH_SIZE Minimum allowable size (in number of vertices) for a disconnected subgraph; subgraphs smaller than these will be removed.
IntHashGrid	spatialIndex
VertexStore	vertexStore

Constructor Summary

Constructors

Constructor and Description
StreetLayer()

Method Summary

Modifier and Type	Method and Description
void	associateStops(TransitLayer transitLayer, int radiusMeters) For every stop in a TransitLayer, find or create a nearby vertex in the street layer and record the connection between the two.
void	buildEdgeLists()
Split	findSplit(double lat, double lon, double radiusMeters) Non-destructively find a location on an existing street near the given point.
int	getOrCreateVertexNear(double lat, double lon, double radiusMeters) Create a street-layer vertex representing a transit stop.
int	getVertexCount()
void	indexStreets()
void	loadFromOsm(com.conveyal.osmlib.OSM osm) Load street layer from an OSM-lib OSM DB
void	removeDisconnectedSubgraphs(int minSubgraphSize) Find and remove all subgraphs with fewer than minSubgraphSize vertices.
void	splitStreet(int fixedLon, int fixedLat, boolean transit, boolean out) Used to split streets for temporary endpoints and for transit stops.
void	testRouting(boolean withDestinations, TransitLayer transitLayer) After JIT this appears to scale almost linearly with number of cores.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

MIN_SUBGRAPH_SIZE

public static final int MIN_SUBGRAPH_SIZE

Minimum allowable size (in number of vertices) for a disconnected subgraph; subgraphs smaller than these will be removed. There are several reasons why one might have a disconnected subgraph. The most common is poor quality OSM data. However, they also could be due to areas that really are disconnected in the street graph, and are connected only by transit. These could be literal islands (Vashon Island near Seattle comes to mind), or islands that are isolated by infrastructure (for example, airport terminals reachable only by transit or driving, for instance BWI or SFO).

See Also:

Constant Field Values

spatialIndex

public transient IntHashGrid spatialIndex

vertexStore

public VertexStore vertexStore

edgeStore

public EdgeStore edgeStore

linkedTransitLayer

public TransitLayer linkedTransitLayer

Constructor Detail

StreetLayer

public StreetLayer()

Method Detail

loadFromOsm

public void loadFromOsm(com.conveyal.osmlib.OSM osm)

Load street layer from an OSM-lib OSM DB

indexStreets

public void indexStreets()

testRouting

public void testRouting(boolean withDestinations,
                        TransitLayer transitLayer)

After JIT this appears to scale almost linearly with number of cores.

buildEdgeLists

public void buildEdgeLists()

getOrCreateVertexNear

public int getOrCreateVertexNear(double lat,
                                 double lon,
                                 double radiusMeters)

Create a street-layer vertex representing a transit stop. Connect that new vertex to the street network if possible. The vertex will be created and assigned an index whether or not it is successfully linked. TODO maybe use X and Y everywhere for fixed point, and lat/lon for double precision degrees. TODO move this into Split.perform(), store streetLayer ref in Split

Returns:

the index of a street vertex very close to this stop, or -1 if no such vertex could be found or created.

findSplit

public Split findSplit(double lat,
                       double lon,
                       double radiusMeters)

Non-destructively find a location on an existing street near the given point. PARAMETERS ARE FLOATING POINT GEOGRAPHIC (not fixed point ints)

Returns:

a Split object representing a point along a sub-segment of a specific edge, or null if there are no streets nearby.

associateStops

public void associateStops(TransitLayer transitLayer,
                           int radiusMeters)

For every stop in a TransitLayer, find or create a nearby vertex in the street layer and record the connection between the two. It only makes sense to link one TransitLayer to one StreetLayer, otherwise the bi-mapping between transit stops and street vertices would be ambiguous.

splitStreet

public void splitStreet(int fixedLon,
                        int fixedLat,
                        boolean transit,
                        boolean out)

Used to split streets for temporary endpoints and for transit stops. transit: favor platforms and pedestrian paths, used in linking stops to streets intoStreetLayer: the edges created by splitting a street are one-way. by default they are one-way out of the street network, e.g. out to a transit stop or to the destination. When intoStreets is true, the split is performed such that it leads into the street network instead of out of it. The fact that split edges are uni-directional is important for a couple of reasons: it avoids using transit stops as shortcuts, and it makes temporary endpoint vertices harmless to searches happening in other threads.

getVertexCount

public int getVertexCount()

removeDisconnectedSubgraphs

public void removeDisconnectedSubgraphs(int minSubgraphSize)

Find and remove all subgraphs with fewer than minSubgraphSize vertices. Uses a flood fill algorithm, see http://stackoverflow.com/questions/1348783.