StreetEdge (OpenTripPlanner 1.5.0-SNAPSHOT API)

java.lang.Object
- org.opentripplanner.routing.graph.Edge
- - org.opentripplanner.routing.edgetype.StreetEdge

All Implemented Interfaces:

Serializable, Cloneable

Direct Known Subclasses:

StreetWithElevationEdge
```
public class StreetEdge
extends Edge
implements Cloneable
```
This represents a street segment.

Author:

novalis

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class org.opentripplanner.routing.graph.Edge
  Edge.ValidVertexTypes

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ANY_PLATFORM_MASK`
`protected float`	`bicycleSafetyFactor` bicycleSafetyWeight = length * bicycleSafetyFactor.
`static int`	`CLASS_CROSSING`
`static int`	`CLASS_LINK`
`static int`	`CLASS_OTHER_PLATFORM`
`static int`	`CLASS_OTHERPATH`
`static int`	`CLASS_STREET`
`static int`	`CLASS_TRAIN_PLATFORM`
`static int`	`CROSSING_CLASS_MASK`
`static float`	`DEFAULT_CAR_SPEED`
`protected float`	`walkComfortScore` The walk comfort score.
`long`	`wayId` The OSM way ID from whence this came - needed to reference traffic data

Fields inherited from class org.opentripplanner.routing.graph.Edge
fromv, tov

Constructor Summary

Constructors
Constructor and Description
`StreetEdge(StreetVertex v1, StreetVertex v2, org.locationtech.jts.geom.LineString geometry, I18NString name, double length, StreetTraversalPermission permission, boolean back)`
`StreetEdge(StreetVertex v1, StreetVertex v2, org.locationtech.jts.geom.LineString geometry, String name, double length, StreetTraversalPermission permission, boolean back)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addCarNetwork(String carNetwork)`
`boolean`	`addVehicleNetwork(String vehicleNetwork)`
`protected void`	`calculateLengthFromGeometry()` calculate the length of this street segement from its geometry
`static double`	`calculateMicromobilitySpeed(double watts, double weight, double beta, double coefficientOfRollingResistance, double aerodynamicDragComponent, double minSpeed, double maxSpeed)` Calculate the approximate speed for a vehicle given slope data, available sustained power output, weight, rolling resistance, aerodynamic drag and bounds on min/max speeds.
`double`	`calculateSpeed(RoutingRequest options, TraverseMode traverseMode, long timeMillis)` Calculate the speed appropriately given the RoutingRequest and traverseMode and the current wall clock time.
`boolean`	`canTraverse(TraverseModeSet modes)` Checks permissions of the street edge if specified modes are allowed to travel.
`boolean`	`canTraverseIncludingBarrier(TraverseMode mode)` This checks if start or end vertex is bollard If it is it creates intersection of street edge permissions and from/to barriers.
`boolean`	`canTurnOnto(Edge e, State state, TraverseMode mode)`
`StreetEdge`	`clone()`
`boolean`	`containsCarNetwork(String carNetwork)`
`boolean`	`containsVehicleNetwork(String vehicleNetwork)`
`float`	`getBicycleSafetyFactor()`
`Set<String>`	`getCarNetworks()`
`float`	`getCarSpeed()`
`double`	`getDistance()`
`PackedCoordinateSequence`	`getElevationProfile()`
`long`	`getEndOsmNodeId()` Get the ending OSM node ID of this edge.
`boolean`	`getFloatingCarDropoffSuitability()`
`boolean`	`getFloatingVehicleDropoffSuitability()`
`org.locationtech.jts.geom.LineString`	`getGeometry()`
`int`	`getInAngle()` Return the azimuth of the first segment in this edge in integer degrees clockwise from South.
`float`	`getMaxSlope()`
`String`	`getName()` Gets english localized name
`String`	`getName(Locale locale)` Gets wanted localization
`Map<String,String>`	`getOsmTags()`
`int`	`getOutAngle()` Return the azimuth of the last segment in this edge in integer degrees clockwise from South.
`StreetTraversalPermission`	`getPermission()`
`I18NString`	`getRawName()` Gets non-localized I18NString (Used when splitting edges)
`double`	`getRollingResistanceCoefficient()`
`double`	`getSlopeSpeedEffectiveLength()`
`double`	`getSlopeWalkSpeedEffectiveLength()`
`double`	`getSlopeWorkCostEffectiveLength()`
`long`	`getStartOsmNodeId()` Get the starting OSM node ID of this edge.
`int`	`getStreetClass()`
`boolean`	`getTNCStopSuitability()`
`protected List<TurnRestriction>`	`getTurnRestrictions(Graph graph)`
`Set<String>`	`getVehicleNetworks()`
`float`	`getWalkComfortScore()`
`boolean`	`hasBogusName()`
`boolean`	`isBack()` Marks that this edge is the reverse of the one defined in the source data.
`boolean`	`isElevationFlattened()`
`boolean`	`isNoThruTraffic()`
`boolean`	`isRoundabout()` Edges are not roundabouts by default.
`boolean`	`isSlopeOverride()`
`boolean`	`isStairs()` This street is a staircase
`boolean`	`isWheelchairAccessible()`
`void`	`setBack(boolean back)`
`void`	`setBicycleSafetyFactor(float bicycleSafetyFactor)`
`void`	`setCarNetworks(Set<String> networks)`
`void`	`setCarSpeed(float carSpeed)`
`void`	`setFloatingCarDropoffSuitability(boolean isSuitable)`
`void`	`setFloatingVehicleDropoffSuitability(boolean isSuitable)`
`void`	`setHasBogusName(boolean hasBogusName)`
`void`	`setName(I18NString name)`
`void`	`setNoThruTraffic(boolean noThruTraffic)`
`void`	`setOsmTags(Map<String,String> osmTags)`
`void`	`setPermission(StreetTraversalPermission permission)`
`void`	`setRoundabout(boolean roundabout)`
`void`	`setSlopeOverride(boolean slopeOverride)`
`void`	`setStairs(boolean stairs)`
`void`	`setStreetClass(int streetClass)`
`void`	`setTNCStopSuitability(boolean isSuitable)`
`void`	`setVehicleNetworks(Set<String> networks)`
`void`	`setWalkComfortScore(float walkComfortScore)`
`void`	`setWheelchairAccessible(boolean wheelchairAccessible)`
`void`	`shareData(StreetEdge reversedEdge)`
`P2<StreetEdge>`	`split(SplitterVertex splitterVertex, boolean destructive, boolean createSemiPermanentEdges)` Split this street edge and return the resulting street edges.
`double`	`timeLowerBound(RoutingRequest options)` Returns a lower bound on traversal time given the routing options.
`String`	`toString()`
`State`	`traverse(State s0)` Traverse this edge.
`double`	`weightLowerBound(RoutingRequest options)` Returns a lower bound on edge weight given the routing options.

Methods inherited from class org.opentripplanner.routing.graph.Edge
getAzimuth, getDirection, getDisplayGeometry, getFromVertex, getId, getToVertex, getTrip, getValidVertexTypes, hashCode, isEquivalentTo, isPartial, isReverseOf, optimisticTraverse, vertexTypesValid

Methods inherited from class java.lang.Object
equals, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - CLASS_STREET
```
public static final int CLASS_STREET
```
    See Also:
    
    Constant Field Values
  - CLASS_CROSSING
```
public static final int CLASS_CROSSING
```
    See Also:
    
    Constant Field Values
  - CLASS_OTHERPATH
```
public static final int CLASS_OTHERPATH
```
    See Also:
    
    Constant Field Values
  - CLASS_OTHER_PLATFORM
```
public static final int CLASS_OTHER_PLATFORM
```
    See Also:
    
    Constant Field Values
  - CLASS_TRAIN_PLATFORM
```
public static final int CLASS_TRAIN_PLATFORM
```
    See Also:
    
    Constant Field Values
  - ANY_PLATFORM_MASK
```
public static final int ANY_PLATFORM_MASK
```
    See Also:
    
    Constant Field Values
  - CROSSING_CLASS_MASK
```
public static final int CROSSING_CLASS_MASK
```
    See Also:
    
    Constant Field Values
  - CLASS_LINK
```
public static final int CLASS_LINK
```
    See Also:
    
    Constant Field Values
  - DEFAULT_CAR_SPEED
```
public static final float DEFAULT_CAR_SPEED
```
    See Also:
    
    Constant Field Values
  - bicycleSafetyFactor
```
protected float bicycleSafetyFactor
```
    bicycleSafetyWeight = length * bicycleSafetyFactor. For example, a 100m street with a safety factor of 2.0 will be considered in term of safety cost as the same as a 150m street with a safety factor of 1.0.
  - wayId
```
public long wayId
```
    The OSM way ID from whence this came - needed to reference traffic data
  - walkComfortScore
```
protected float walkComfortScore
```
    The walk comfort score. Applied as multiplier to edge weight; 1.0 is baseline
- Constructor Detail
  - StreetEdge
```
public StreetEdge(StreetVertex v1,
                  StreetVertex v2,
                  org.locationtech.jts.geom.LineString geometry,
                  I18NString name,
                  double length,
                  StreetTraversalPermission permission,
                  boolean back)
```
  - StreetEdge
```
public StreetEdge(StreetVertex v1,
                  StreetVertex v2,
                  org.locationtech.jts.geom.LineString geometry,
                  String name,
                  double length,
                  StreetTraversalPermission permission,
                  boolean back)
```
- Method Detail
  - canTraverse
```
public boolean canTraverse(TraverseModeSet modes)
```
    Checks permissions of the street edge if specified modes are allowed to travel. Barriers aren't taken into account. So it can happen that canTraverse returns True. But doTraverse returns false. Since there are barriers on a street. This is because this function is used also on street when searching for start/stop. Those streets are then split. On splitted streets can be possible to drive with a CAR because it is only blocked from one way.
    
    Parameters:
    
    modes -
    
    Returns:
  - canTraverseIncludingBarrier
```
public boolean canTraverseIncludingBarrier(TraverseMode mode)
```
    This checks if start or end vertex is bollard If it is it creates intersection of street edge permissions and from/to barriers. Then it checks if mode is allowed to traverse the edge. By default CAR isn't allowed to traverse barrier but foot and bicycle are. This can be changed with different tags If start/end isn't bollard it just checks the street permissions. It is used in canTraverse(RoutingRequest, TraverseMode)
    
    Parameters:
    
    mode -
    
    Returns:
  - getElevationProfile
```
public PackedCoordinateSequence getElevationProfile()
```
  - isElevationFlattened
```
public boolean isElevationFlattened()
```
  - getMaxSlope
```
public float getMaxSlope()
```
  - getDistance
```
public double getDistance()
```
    Overrides:
    
    getDistance in class Edge
  - traverse
```
public State traverse(State s0)
```
    Description copied from class: Edge
    
    Traverse this edge.
    
    Specified by:
    
    traverse in class Edge
    
    Parameters:
    
    s0 - The State coming into the edge.
    
    Returns:
    
    The State upon exiting the edge.
  - calculateSpeed
```
public double calculateSpeed(RoutingRequest options,
                             TraverseMode traverseMode,
                             long timeMillis)
```
    Calculate the speed appropriately given the RoutingRequest and traverseMode and the current wall clock time. Note: this is not strictly symmetrical, because in a forward search we get the speed based on the time we enter this edge, whereas in a reverse search we get the speed based on the time we exit the edge.
  - getRollingResistanceCoefficient
```
public double getRollingResistanceCoefficient()
```
  - weightLowerBound
```
public double weightLowerBound(RoutingRequest options)
```
    Description copied from class: Edge
    
    Returns a lower bound on edge weight given the routing options.
    
    Overrides:
    
    weightLowerBound in class Edge
    
    Returns:
    
    edge weight as a double.
  - timeLowerBound
```
public double timeLowerBound(RoutingRequest options)
```
    Description copied from class: Edge
    
    Returns a lower bound on traversal time given the routing options.
    
    Overrides:
    
    timeLowerBound in class Edge
    
    Returns:
    
    edge weight as a double.
  - calculateMicromobilitySpeed
```
public static double calculateMicromobilitySpeed(double watts,
                                                 double weight,
                                                 double beta,
                                                 double coefficientOfRollingResistance,
                                                 double aerodynamicDragComponent,
                                                 double minSpeed,
                                                 double maxSpeed)
```
    Calculate the approximate speed for a vehicle given slope data, available sustained power output, weight, rolling resistance, aerodynamic drag and bounds on min/max speeds. This calculation is made using a formula derived from the equations relating to determing total resistive force that is needed to be overcome to maintain a certain velocity. The website at http://www.kreuzotter.de/english/espeed.htm goes into great detail regarding this and presents the following equation which also appears on other websites such as https://www.gribble.org/cycling/power_v_speed.html. P = Cm * V * (Cd * A * ρ/2 * (V + W) ^ 2 + Frg + V * Crvn) where: P = power in watts Cm = Coefficient for power transmission losses and losses due to tire slippage V = velocity in m/s Cd = Coefficient of aerodynamic drag A = frontal area in m^2 ρ = air density in kg/m^3 W = wind speed in m/s (if positive this is a headwind, if negative this is a tailwind) Frg = Rolling friction (normalized on inclined plane) plus slope pulling force on inclined plane Crvn = The coefficient for the dynamic rolling resistance, normalized to road inclination. This equation is then rearranged in an attempt to solve for V on their website as the following: V^3 + V^2 * 2 * (W + Crvn / (Cd * A * ρ)) + V * (W^2 + (2 * Frg) / (Cd * A * ρ)) - (2 * P) / (Cm * Cd * A * ρ) = 0 Then, using the cardanic formulae, the following solutions are found: a = (W^3 - Crvn^3) / 27 - (W * (5 * W * Crvn + (8 * Crvn^2) / (Cd * A * ρ) - 6 * Frg)) / (9 * Cd * A * ρ) + (2 * Frg * Crvn) / (3 * (Cd * A * ρ)^2) + P / (Cm * Cd * A * ρ) b = (2 / (9 * Cd * A * ρ)) * (3 * Frg - 4 * W * Crvn - (W^2) * Cd * A * ρ/2 - (2 * Crvn) / (Cd * A * ρ)) If a^2 + b^3 ≥ 0: V = cbrt(a + sqrt(a^2 + b^3)) + cbrt(a - sqrt(a^2 + b^3)) - (2 / 3) * (W + Crvn / (Cd * A * ρ)) If a^2 + b^3 < 0: V = 2 * sqrt(-b) * cos((1 / 3) * arccos(a / sqrt(-b^3)) - (2 / 3) * (W + Crvn / (Cd * A * ρ)) Although it could be possible to try to estimate wind speed using weather data, for now wind speed is assumed to be 0. Therefore, the above equations can be changed to exlude the parts where the wind speed being 0 would cause various components to no longer be needed. Thus these solutions are used: a = (- Crvn^3) / 27 + (2 * Frg * Crvn) / (3 * (Cd * A * ρ)^2) + P / (Cm * Cd * A * ρ) b = (2 / (9 * Cd * A * ρ)) * (3 * Frg - (2 * Crvn) / (Cd * A * ρ)) If a^2 + b^3 ≥ 0: V = cbrt(a + sqrt(a^2 + b^3)) + cbrt(a - sqrt(a^2 + b^3)) - (2 / 3) * (Crvn / (Cd * A * ρ)) If a^2 + b^3 < 0: V = 2 * sqrt(-b) * cos((1 / 3) * arccos(a / sqrt(-b^3)) - (2 / 3) * (Crvn / (Cd * A * ρ))
    
    Parameters:
    
    watts - The sustained power output in watts. This represents the value of `P` in the above equations.
    
    weight - The total weight required to be moved that includes the rider(s), their belongings and the vehicle weight.
    
    beta - ("beta") Inclination angle, = arctan(grade/100). It's probably not a huge time savings and would use more memory, but additional precalculations from this value could be made. This value is used to calculate the values of `Crvn` and `Frg` as noted in the above equations.
    
    coefficientOfRollingResistance - The coefficient of rolling resistance. This can also be used to model the difficulty of traveling over bumpy roadways. This value is used to calculate the value of `Frg` as noted in the above equations.See this wikipedia page for a list of coefficients by various surface types: https://en.wikipedia.org/wiki/Rolling_resistance#Rolling_resistance_coefficient_examples
    
    aerodynamicDragComponent - The product of the coefficient of aerodynamic drag, frontal area and air density. This value is product of (Cd * A * ρ) as noted in the above mathematical equations.
    
    minSpeed - The minimum speed that the micromobility should travel at in cases where the slope is so steep that it would be faster to walk with the vehicle.
    
    maxSpeed - The maximum speed the vehicle can travel at.
    
    Returns:
    
    The speed in m/s. This represents the value of `V` in the above mathematical equations.
  - getSlopeSpeedEffectiveLength
```
public double getSlopeSpeedEffectiveLength()
```
  - getSlopeWorkCostEffectiveLength
```
public double getSlopeWorkCostEffectiveLength()
```
  - getSlopeWalkSpeedEffectiveLength
```
public double getSlopeWalkSpeedEffectiveLength()
```
  - setBicycleSafetyFactor
```
public void setBicycleSafetyFactor(float bicycleSafetyFactor)
```
  - getBicycleSafetyFactor
```
public float getBicycleSafetyFactor()
```
  - setWalkComfortScore
```
public void setWalkComfortScore(float walkComfortScore)
```
  - getWalkComfortScore
```
public float getWalkComfortScore()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Edge
  - clone
```
public StreetEdge clone()
```
    Overrides:
    
    clone in class Object
  - canTurnOnto
```
public boolean canTurnOnto(Edge e,
                           State state,
                           TraverseMode mode)
```
  - getName
```
public String getName()
```
    Description copied from class: Edge
    
    Gets english localized name
    
    Specified by:
    
    getName in class Edge
    
    Returns:
    
    english localized name
  - getRawName
```
public I18NString getRawName()
```
    Gets non-localized I18NString (Used when splitting edges)
    
    Returns:
    
    non-localized Name
  - getName
```
public String getName(Locale locale)
```
    Description copied from class: Edge
    
    Gets wanted localization
    
    Specified by:
    
    getName in class Edge
    
    Parameters:
    
    locale - wanted locale
    
    Returns:
    
    Localized in specified locale name
  - setName
```
public void setName(I18NString name)
```
  - getGeometry
```
public org.locationtech.jts.geom.LineString getGeometry()
```
    Overrides:
    
    getGeometry in class Edge
  - shareData
```
public void shareData(StreetEdge reversedEdge)
```
  - isWheelchairAccessible
```
public boolean isWheelchairAccessible()
```
  - setWheelchairAccessible
```
public void setWheelchairAccessible(boolean wheelchairAccessible)
```
  - getPermission
```
public StreetTraversalPermission getPermission()
```
  - setPermission
```
public void setPermission(StreetTraversalPermission permission)
```
  - getStreetClass
```
public int getStreetClass()
```
  - setStreetClass
```
public void setStreetClass(int streetClass)
```
  - isBack
```
public boolean isBack()
```
    Marks that this edge is the reverse of the one defined in the source data. Does NOT mean fromv/tov are reversed.
  - setBack
```
public void setBack(boolean back)
```
  - isRoundabout
```
public boolean isRoundabout()
```
    Description copied from class: Edge
    
    Edges are not roundabouts by default.
    
    Overrides:
    
    isRoundabout in class Edge
  - setRoundabout
```
public void setRoundabout(boolean roundabout)
```
  - hasBogusName
```
public boolean hasBogusName()
```
    Overrides:
    
    hasBogusName in class Edge
  - setHasBogusName
```
public void setHasBogusName(boolean hasBogusName)
```
  - isNoThruTraffic
```
public boolean isNoThruTraffic()
```
  - setNoThruTraffic
```
public void setNoThruTraffic(boolean noThruTraffic)
```
  - isStairs
```
public boolean isStairs()
```
    This street is a staircase
  - setStairs
```
public void setStairs(boolean stairs)
```
  - getCarSpeed
```
public float getCarSpeed()
```
  - setCarSpeed
```
public void setCarSpeed(float carSpeed)
```
  - setCarNetworks
```
public void setCarNetworks(Set<String> networks)
```
  - getCarNetworks
```
public Set<String> getCarNetworks()
```
  - setVehicleNetworks
```
public void setVehicleNetworks(Set<String> networks)
```
  - getVehicleNetworks
```
public Set<String> getVehicleNetworks()
```
  - setTNCStopSuitability
```
public void setTNCStopSuitability(boolean isSuitable)
```
  - getTNCStopSuitability
```
public boolean getTNCStopSuitability()
```
  - setFloatingCarDropoffSuitability
```
public void setFloatingCarDropoffSuitability(boolean isSuitable)
```
  - getFloatingCarDropoffSuitability
```
public boolean getFloatingCarDropoffSuitability()
```
  - setFloatingVehicleDropoffSuitability
```
public void setFloatingVehicleDropoffSuitability(boolean isSuitable)
```
  - getFloatingVehicleDropoffSuitability
```
public boolean getFloatingVehicleDropoffSuitability()
```
  - isSlopeOverride
```
public boolean isSlopeOverride()
```
  - setSlopeOverride
```
public void setSlopeOverride(boolean slopeOverride)
```
  - getInAngle
```
public int getInAngle()
```
    Return the azimuth of the first segment in this edge in integer degrees clockwise from South. TODO change everything to clockwise from North
  - getOutAngle
```
public int getOutAngle()
```
    Return the azimuth of the last segment in this edge in integer degrees clockwise from South.
  - getTurnRestrictions
```
protected List<TurnRestriction> getTurnRestrictions(Graph graph)
```
  - calculateLengthFromGeometry
```
protected void calculateLengthFromGeometry()
```
    calculate the length of this street segement from its geometry
  - split
```
public P2<StreetEdge> split(SplitterVertex splitterVertex,
                            boolean destructive,
                            boolean createSemiPermanentEdges)
```
    Split this street edge and return the resulting street edges. There are 3 possible types of splits: 1. A destructive split where two new StreetEdges are created from the existing edge. The edge that was split has its reference removed from its from and to vertices in the StreetSplitter class thus permanently removing the possibility of the original edge being traversed in subsequent searches. This split method should only be used when building a graph. Another important note is that in destructive splits, regular StreetEdges are created without elevation data, but typically these destructive splits occur in graph build modules that occur before adding in elevation data. 2. A semi-permanent split is typically used in an updater to create vertices and edges that are specifically for a single rental car/bike/vehicle station. Further splits of semi-permanent edges are only allowed for linking the origin and destination for the graph. See SemiPermanentPartialStreetEdge.split. The original edge is still traversable in the graph. 3. A temporary split is used to link a StreetEdge to an origin or destination. In this case there is only a need for creating outgoing edges from the origin and incoming edges to the destination. // TODO: there is also something about half edges which may not be needed anymore?
    
    Parameters:
    
    splitterVertex - The new vertex that the newly split edge(s) will become connected to.
    
    destructive - Whether or not the split should be permanent and result in the old edge no longer existing within the graph.
    
    createSemiPermanentEdges - Whether or not the split should result in the creation of semi-permanent edges or temporary edges.
  - getStartOsmNodeId
```
public long getStartOsmNodeId()
```
    Get the starting OSM node ID of this edge. Note that this information is preserved when an edge is split, so both edges will have the same starting and ending nodes.
  - getEndOsmNodeId
```
public long getEndOsmNodeId()
```
    Get the ending OSM node ID of this edge. Note that this information is preserved when an edge is split, so both edges will have the same starting and ending nodes.
  - getOsmTags
```
public Map<String,String> getOsmTags()
```
  - setOsmTags
```
public void setOsmTags(Map<String,String> osmTags)
```
  - addCarNetwork
```
public boolean addCarNetwork(String carNetwork)
```
  - containsCarNetwork
```
public boolean containsCarNetwork(String carNetwork)
```
  - addVehicleNetwork
```
public boolean addVehicleNetwork(String vehicleNetwork)
```
  - containsVehicleNetwork
```
public boolean containsVehicleNetwork(String vehicleNetwork)
```

Class StreetEdge

Nested Class Summary

Nested classes/interfaces inherited from class org.opentripplanner.routing.graph.Edge

Field Summary

Fields inherited from class org.opentripplanner.routing.graph.Edge

Constructor Summary

Method Summary

Methods inherited from class org.opentripplanner.routing.graph.Edge

Methods inherited from class java.lang.Object

Field Detail

CLASS_STREET

CLASS_CROSSING

CLASS_OTHERPATH

CLASS_OTHER_PLATFORM

CLASS_TRAIN_PLATFORM

ANY_PLATFORM_MASK

CROSSING_CLASS_MASK

CLASS_LINK

DEFAULT_CAR_SPEED

bicycleSafetyFactor

wayId

walkComfortScore

Constructor Detail

StreetEdge

StreetEdge

Method Detail

canTraverse

canTraverseIncludingBarrier

getElevationProfile

isElevationFlattened

getMaxSlope

getDistance

traverse

calculateSpeed

getRollingResistanceCoefficient

weightLowerBound

timeLowerBound

calculateMicromobilitySpeed

getSlopeSpeedEffectiveLength

getSlopeWorkCostEffectiveLength

getSlopeWalkSpeedEffectiveLength

setBicycleSafetyFactor

getBicycleSafetyFactor

setWalkComfortScore

getWalkComfortScore

toString

clone

canTurnOnto

getName

getRawName

getName

setName

getGeometry

shareData

isWheelchairAccessible

setWheelchairAccessible

getPermission

setPermission

getStreetClass

setStreetClass

isBack

setBack

isRoundabout

setRoundabout

hasBogusName

setHasBogusName

isNoThruTraffic

setNoThruTraffic

isStairs

setStairs

getCarSpeed

setCarSpeed

setCarNetworks

getCarNetworks

setVehicleNetworks

getVehicleNetworks

setTNCStopSuitability

getTNCStopSuitability

setFloatingCarDropoffSuitability

getFloatingCarDropoffSuitability