Skip navigation links

oracle.spatial.network.lod
Class NetworkAnalyst

java.lang.Object
oracle.spatial.network.lod.NetworkAnalyst

public class NetworkAnalyst

extends java.lang.Object

This class is the single entry point to all the network analysis operations supported by NDM LOD. To get an instance of this class, use

    NetworkAnalyst analyst = LODNetworkManager.getNetworkAnalyst(networkIO);
  

where networkIO is an NetworkIO object for the network of interest.

Users can define their own link cost calculators or node cost calculators. Note that if you choose to use your own link or node cost calculators, you must set both link and node cost calculators in pairs, that is, there must be the same number of link cost calculators as that of the node cost calculators, and the ith link cost calculator must correspond to the ith node cost calculator.

Since:

11gR1

Field Summary

static int	BREADTH_FIRST_SEARCH Constant for bread-first-search
static int	DEPTH_FIRST_SEARCH Constant for depth-first-search

Method Summary

OrderedLongSet[]	findConnectedComponents(int linkLevel) Finds the connected components for the specified link level.
int	findConnectedComponentsInPartition(int partitionId, int linkLevel, int startComponentId, java.util.ArrayList<oracle.spatial.network.lod.AnalysisUtility.NodeComponent> nodeComponentArray) Finds the connected components for the specified link level.
OrderedLongSet	findConnectedNodes(int searchMethod, long nodeId, int linkLevel, LODNetworkConstraint constraint, LODGoalNode goalNode) Finds the nodes connected to the specified node.
OrderedLongSet	findReachableNodes(int searchMethod, long startNodeId, int linkLevel, LODNetworkConstraint constraint, LODGoalNode goalNode) Finds the nodes reachable from the specified node.
OrderedLongSet	findReachingNodes(int searchMethod, long endNodeId, int linkLevel, LODNetworkConstraint constraint, LODGoalNode goalNode) Finds the nodes that can reach the specified node.
LinkCostCalculator	getLinkCostCalculator() Deprecated. use getLinkCostCalculators()
LinkCostCalculator[]	getLinkCostCalculators() Returns the link cost calculators.
NetworkExplorer	getNetworkExplorer() Returns the network explorer used by this network analyst.
NodeCostCalculator	getNodeCostCalculator() Deprecated. use getNodeCostCalculators()
NodeCostCalculator[]	getNodeCostCalculators() Returns the node cost calculators.
boolean	isReachable(long startNodeId, long endNodeId, int linkLevel, LODNetworkConstraint constraint) Checks whether there is a path from the start node to the end node using the specified link level for long-haul search.
LogicalSubPath[]	kShortestPaths(PointOnNet[] startPoint, PointOnNet[] endPoint, int k, LODNetworkConstraint constraint, KShortestPaths kspAlgorithm) Returns K shortest loopless paths from the start point candiates to the end point candidates.
long[]	mcst(int linkLevel, LODNetworkConstraint constraint, NetworkUpdate tmpNetworkUpdate) Returns the link IDs of the minimum-spanning-tree.
LogicalSubPath[]	nearestNeighbors(PointOnNet[] startPoints, int numberOfNeighbors, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest neighbors from the specified start point candidates.
LogicalSubPath[]	nearestNeighbors(PointOnNet startPoint, int numberOfNeighbors, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest neighbors from the specified start point.
LogicalSubPath[]	nearestNeighbors(PointOnNet startPoint, int numberOfNeighbors, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest neighbors from the specified start point.
LogicalSubPath[]	nearestNeighbors(PointOnNet startPoint, int numberOfNeighbors, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest neighbors from the specified start point.
LogicalLightSubPath[]	nearestNeighborsLight(PointOnNet[] startPoints, int numberOfNeighbors, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest neighbors from the specified start point candidates.
LogicalSubPath[]	nearestReachingNeighbors(PointOnNet[] endPoints, int numberOfNeighbors, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest reaching neighbors to the specified end point candidates.
LogicalSubPath[]	nearestReachingNeighbors(PointOnNet endPoint, int numberOfNeighbors, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest reaching neighbors to the specified end point.
LogicalSubPath[]	nearestReachingNeighbors(PointOnNet endPoint, int numberOfNeighbors, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest reaching neighbors to the specified end point.
LogicalSubPath[]	nearestReachingNeighbors(PointOnNet endPoint, int numberOfNeighbors, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest reaching neighbors to the specified end point.
LogicalLightSubPath[]	nearestReachingNeighborsLight(PointOnNet[] endPoints, int numberOfNeighbors, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nearest reaching neighbors to the specified end point candidates.
NetworkBuffer	networkBuffer(PointOnNet[] startPoints, double cost, LODNetworkConstraint constraint) Computes network buffer within the specified cost from the start point candidates.
NetworkBuffer	reachingNetworkBuffer(PointOnNet[] endPoints, double cost, LODNetworkConstraint constraint) Computes network buffer within the specified cost to the end point candidates.
void	resetCostCalculators() Restores the default settings of link cost calculators and node cost calculators, which uses the DefaultLinkCostCalculator as the primary link cost calculator and the DefaultNodeCostCalculator as the primary node cost calculator.
void	setLinkCostCalculator(LinkCostCalculator calculator) Deprecated. use setLinkCostCalculators()
void	setLinkCostCalculators(LinkCostCalculator[] calculators) Sets the link cost calculators.
void	setNetworkUpdate(java.util.HashMap<java.lang.Integer,NetworkUpdate> networkUpdates) Deprecated. use setNetworkUpdates instead
void	setNetworkUpdates(java.util.HashMap<java.lang.Integer,NetworkUpdate> networkUpdates) Sets the network update objects.
void	setNodeCostCalculator(NodeCostCalculator calculator) Deprecated. use setNodeCostCalculators()
void	setNodeCostCalculators(NodeCostCalculator[] calculators) Sets the node cost calculators.
LogicalSubPath	shortestPathAStar(PointOnNet[] startPoints, PointOnNet[] endPoints, LODNetworkConstraint constraint, HeuristicCostFunction hcf, LinkLevelSelector lls) Finds the shortest path using A* algorithm with dynamic link level selector.
LogicalSubPath	shortestPathAStar(PointOnNet startPoint, PointOnNet endPoint, int searchLinkLevel, LODNetworkConstraint constraint, HeuristicCostFunction hcf, double[] costThresholds) Finds the shortest path using A* algorithm using dynamic link level selector.
LogicalSubPath	shortestPathAStar(PointOnNet startPoint, PointOnNet endPoint, LODNetworkConstraint constraint, HeuristicCostFunction hcf, double[] costThresholds) Finds the shortest path using A* algorithm using dynamic link level selector.
LogicalSubPath	shortestPathAStar(PointOnNet startPoint, PointOnNet endPoint, LODNetworkConstraint constraint, HeuristicCostFunction hcf, LinkLevelSelector lls) Finds the shortest path using A* algorithm using dynamic link level selector of this NetworkAnalyst.
LogicalSubPath	shortestPathDijkstra(PointOnNet[] startPoints, PointOnNet[] endPoints, int searchLinkLevel, int maxHighLevelNodesToConsider, LODNetworkConstraint constraint) Finds the shortest path using Dijkstra algorithm with static link level selector.
LogicalSubPath	shortestPathDijkstra(PointOnNet[] startPoints, PointOnNet[] endPoints, int searchLinkLevel, LODNetworkConstraint constraint) Finds the shortest path using Dijkstra algorithm with static link level selector.
LogicalSubPath	shortestPathDijkstra(PointOnNet startPoint, PointOnNet endPoint, int searchLinkLevel, LODNetworkConstraint constraint) Finds the shortest path using Dijkstra algorithm with static link level selector.
LogicalSubPath	shortestPathDijkstra(PointOnNet startPoint, PointOnNet endPoint, LODNetworkConstraint constraint) Finds the shortest path using Dijkstra algorithm and the analyst's link level selector specified by the user.
LogicalSubPath	shortestPathDijkstraMaxLevel(PointOnNet startPoint, PointOnNet endPoint, LODNetworkConstraint constraint) Finds the shortest path using Dijkstra algorithm where the long-haul path is computed on the maximum link level.
LogicalSubPath	shortestPathHierarchical(PointOnNet[] startPoints, PointOnNet[] endPoints, int searchLinkLevel, int maxHighLevelNodesToConsider, LODNetworkConstraint constraint, ShortestPath algorithm) Finds the shortest path from a point on the start link to the end node.
LogicalSubPath[]	traceIn(PointOnNet[] endPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryPointsOnly) Finds the nodes and partial links within the specified cost to the end point candidates.
LogicalSubPath[]	traceIn(PointOnNet endPoint, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes and partial links within the specified cost to the end point.
LogicalSubPath[]	traceIn(PointOnNet endPoint, double cost, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes and partial links within the specified cost to the end point.
LogicalSubPath[]	traceIn(PointOnNet endPoint, double cost, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes and partial links within the specified cost to the end point.
LogicalLightSubPath[]	traceInLight(PointOnNet[] startPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryPointsOnly) Finds the nodes and partial links within the specified cost to the end point candidates.
LogicalSubPath[]	traceOut(PointOnNet[] startPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryPointsOnly) Finds the nodes and partial links within the specified cost from the start point candidates.
LogicalSubPath[]	traceOut(PointOnNet startPoint, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes and partial links within the specified cost from the start point.
LogicalSubPath[]	traceOut(PointOnNet startPoint, double cost, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes and partial links within the specified cost from the start point.
LogicalSubPath[]	traceOut(PointOnNet startPoint, double cost, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes and partial links within the specified cost from the start point.
LogicalLightSubPath[]	traceOutLight(PointOnNet[] startPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryPointsOnly) Finds the nodes and partial links within the specified cost from the start points.
TspPath	tsp(PointOnNet[][] pointsToVisit, TSP.TourFlag tourFlag, int linkLevel, LODNetworkConstraint constraint) Returns the traveling salesman tour for the specified points.
TspPath	tsp(PointOnNet[][] pointsToVisit, TSP.TourFlag tourFlag, int linkLevel, LODNetworkConstraint constraint, TSP algorithm) Returns the traveling salesman tour for the specified points.
LogicalSubPath[]	withinCost(PointOnNet[] startPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryNodesOnly) Finds the nodes within the specified cost from the start point candidates.
LogicalSubPath[]	withinCost(PointOnNet startPoint, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes within the specified cost from the start point.
LogicalSubPath[]	withinCost(PointOnNet startPoint, double cost, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes within the specified cost from the start point.
LogicalSubPath[]	withinCost(PointOnNet startPoint, double cost, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes within the specified cost from the start point.
LogicalLightSubPath[]	withinCostLight(PointOnNet[] startPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryNodesOnly) Finds the nodes within the specified cost from the start point candidates.
JGeometry	withinCostPolygon(PointOnNet[] startPoints, double cost, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Returns the polygon covering the nodes, links or partial links that are within the given cost from the start point candidates.
LogicalSubPath[]	withinReachingCost(PointOnNet[] endPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryNodesOnly) Finds the nodes within the specified cost to the end point candidates.
LogicalSubPath[]	withinReachingCost(PointOnNet endPoint, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes within the specified cost to the end point.
LogicalSubPath[]	withinReachingCost(PointOnNet endPoint, double cost, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes within the specified cost to the end point.
LogicalSubPath[]	withinReachingCost(PointOnNet endPoint, double cost, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Finds the nodes within the specified cost to the end point.
LogicalLightSubPath[]	withinReachingCostLight(PointOnNet[] endPoints, double cost, int searchLinkLevel, int targetLinkLevel, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter, boolean returnBoundaryNodesOnly) Finds the nodes within the specified cost to the end points.
JGeometry	withinReachingCostPolygon(PointOnNet[] endPoints, double cost, LODNetworkConstraint constraint, LODGoalNode goalNodeFilter) Returns the polygon covering the nodes, links or partial links that are within the given cost to the end point candidates.

Methods inherited from class java.lang.Object

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

Field Detail

BREADTH_FIRST_SEARCH

public static final int BREADTH_FIRST_SEARCH

Constant for bread-first-search

See Also:

Constant Field Values

DEPTH_FIRST_SEARCH

public static final int DEPTH_FIRST_SEARCH

Constant for depth-first-search

See Also:

Constant Field Values

Method Detail

getNetworkExplorer

public NetworkExplorer getNetworkExplorer()

Returns the network explorer used by this network analyst.

setNetworkUpdates

public void setNetworkUpdates(java.util.HashMap<java.lang.Integer,NetworkUpdate> networkUpdates)

Sets the network update objects. These objects will be super imposed to the static network information during network analysis.

Parameters:

networkUpdates - network update objects for different link levels

setNetworkUpdate

public void setNetworkUpdate(java.util.HashMap<java.lang.Integer,NetworkUpdate> networkUpdates)

Deprecated. use setNetworkUpdates instead

Sets the network update objects. These objects will be super imposed to the static network information during network analysis.

Parameters:

networkUpdates - network update objects for different link levels

resetCostCalculators

public void resetCostCalculators()

Restores the default settings of link cost calculators and node cost calculators, which uses the DefaultLinkCostCalculator as the primary link cost calculator and the DefaultNodeCostCalculator as the primary node cost calculator. No secondary cost calculators are set.

setLinkCostCalculator

public void setLinkCostCalculator(LinkCostCalculator calculator)

Deprecated. use setLinkCostCalculators()

Sets the primary link cost calculator, and removes all secondary link cost calculators. The primary link cost calculator is used to calculate the objective cost during network analysis.

Parameters:

calculator - link cost calculator

getLinkCostCalculator

public LinkCostCalculator getLinkCostCalculator()

Deprecated. use getLinkCostCalculators()

Returns the primary link cost calculator. The primary link cost calculator is used to calculate the objective cost during network analysis.

Returns:

link cost calculator

setNodeCostCalculator

public void setNodeCostCalculator(NodeCostCalculator calculator)

Deprecated. use setNodeCostCalculators()

Sets the primary node cost calculator, and removes all secondary node cost calculators. The primary node cost calculator is used to calculate the objective cost during network analysis.

Parameters:

calculator - node cost calculator

getNodeCostCalculator

public NodeCostCalculator getNodeCostCalculator()

Deprecated. use getNodeCostCalculators()

Returns the primary node cost calculator. The primary node cost calculator is used to calculate the objective cost during network analysis.

Returns:

node cost calculator

setLinkCostCalculators

public void setLinkCostCalculators(LinkCostCalculator[] calculators)

Sets the link cost calculators. The first element in the array is the primary link cost calculator, which is used in calculating the objective cost during network analysis. The rest of the elements in the the array are secondary cost calculators, which can be used in network constraints.

Parameters:

calculators - link cost calculators

getLinkCostCalculators

public LinkCostCalculator[] getLinkCostCalculators()

Returns the link cost calculators. The first element in the array is the primary link cost calculator, which is used in calculating the objective cost during network analysis. The rest of the elements in the the array are secondary cost calculators, which can be used in network constraints.

Returns:

link cost calculators

setNodeCostCalculators

public void setNodeCostCalculators(NodeCostCalculator[] calculators)

Sets the node cost calculators. The first element in the array is the primary node cost calculator, which is used in calculating the objective cost during network analysis. The rest of the elements in the the array are secondary cost calculators, which can be used in network constraints.

Parameters:

calculators - node cost calculators

getNodeCostCalculators

public NodeCostCalculator[] getNodeCostCalculators()

Returns the node cost calculators. The first element in the array is the primary node cost calculator, which is used in calculating the objective cost during network analysis. The rest of the elements in the the array are secondary cost calculators, which can be used in network constraints.

Returns:

node cost calculators

nearestNeighbors

public LogicalSubPath[] nearestNeighbors(PointOnNet startPoint,
                                         int numberOfNeighbors,
                                         LODNetworkConstraint constraint,
                                         LODGoalNode goalNodeFilter)
                                  throws LODNetworkException

Finds the nearest neighbors from the specified start point. Both the search and the target link level are set to the lowest link level

Parameters:

startPoint - start point on the network

numberOfNeighbors - number of neighbors to be returned

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the nearest neighbors from the start point

Throws:

LODNetworkException

nearestNeighbors

public LogicalSubPath[] nearestNeighbors(PointOnNet startPoint,
                                         int numberOfNeighbors,
                                         int targetLinkLevel,
                                         LODNetworkConstraint constraint,
                                         LODGoalNode goalNodeFilter)
                                  throws LODNetworkException

Finds the nearest neighbors from the specified start point. The search uses the lowest link level.

Parameters:

startPoint - start point on the network

numberOfNeighbors - number of neighbors to be returned

targetLinkLevel - maximum outgoing link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the nearest neighbors from the start point

Throws:

LODNetworkException

nearestNeighbors

public LogicalSubPath[] nearestNeighbors(PointOnNet startPoint,
                                         int numberOfNeighbors,
                                         int searchLinkLevel,
                                         int targetLinkLevel,
                                         LODNetworkConstraint constraint,
                                         LODGoalNode goalNodeFilter)
                                  throws LODNetworkException

Finds the nearest neighbors from the specified start point.

Parameters:

startPoint - start point on the network

numberOfNeighbors - number of neighbors to be returned

searchLinkLevel - the link level to search for neighbors

targetLinkLevel - maximum outgoing link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the nearest neighbors from the start point

Throws:

LODNetworkException

nearestNeighbors

public LogicalSubPath[] nearestNeighbors(PointOnNet[] startPoints,
                                         int numberOfNeighbors,
                                         int searchLinkLevel,
                                         int targetLinkLevel,
                                         LODNetworkConstraint constraint,
                                         LODGoalNode goalNodeFilter)
                                  throws LODNetworkException

Finds the nearest neighbors from the specified start point candidates.

Parameters:

startPoints - start point candidates on the network

numberOfNeighbors - number of neighbors to be returned

searchLinkLevel - the link level to search for neighbors

targetLinkLevel - maximum outgoing link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the nearest neighbors from the start point candidates

Throws:

LODNetworkException

nearestNeighborsLight

public LogicalLightSubPath[] nearestNeighborsLight(PointOnNet[] startPoints,
                                                   int numberOfNeighbors,
                                                   int searchLinkLevel,
                                                   int targetLinkLevel,
                                                   LODNetworkConstraint constraint,
                                                   LODGoalNode goalNodeFilter)
                                            throws LODNetworkException

Finds the nearest neighbors from the specified start point candidates.

Parameters:

startPoints - start point candidates on the network

numberOfNeighbors - number of neighbors to be returned

searchLinkLevel - the link level to search for neighbors

targetLinkLevel - maximum outgoing link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the nearest neighbors from the start point candidates

Throws:

LODNetworkException

nearestReachingNeighbors

public LogicalSubPath[] nearestReachingNeighbors(PointOnNet endPoint,
                                                 int numberOfNeighbors,
                                                 LODNetworkConstraint constraint,
                                                 LODGoalNode goalNodeFilter)
                                          throws LODNetworkException

Finds the nearest reaching neighbors to the specified end point. Both the search and the target link levels are set to the lowest link level.

Parameters:

endPoint - end point on the network

numberOfNeighbors - number of neighbors to be returned

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the nearest reaching neighbors to the end point

Throws:

LODNetworkException

nearestReachingNeighbors

public LogicalSubPath[] nearestReachingNeighbors(PointOnNet endPoint,
                                                 int numberOfNeighbors,
                                                 int targetLinkLevel,
                                                 LODNetworkConstraint constraint,
                                                 LODGoalNode goalNodeFilter)
                                          throws LODNetworkException

Finds the nearest reaching neighbors to the specified end point. The search uses the lowest link level.

Parameters:

endPoint - end point on the network

numberOfNeighbors - number of neighbors to be returned

targetLinkLevel - maximum incoming link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the nearest reaching neighbors to the end point

Throws:

LODNetworkException

nearestReachingNeighbors

public LogicalSubPath[] nearestReachingNeighbors(PointOnNet endPoint,
                                                 int numberOfNeighbors,
                                                 int searchLinkLevel,
                                                 int targetLinkLevel,
                                                 LODNetworkConstraint constraint,
                                                 LODGoalNode goalNodeFilter)
                                          throws LODNetworkException

Finds the nearest reaching neighbors to the specified end point.

Parameters:

endPoint - end point on the network

numberOfNeighbors - number of neighbors to be returned

searchLinkLevel - the preferred link level to search for neighbors

targetLinkLevel - maximum incoming link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the nearest reaching neighbors to the end point candidates

Throws:

LODNetworkException

nearestReachingNeighbors

public LogicalSubPath[] nearestReachingNeighbors(PointOnNet[] endPoints,
                                                 int numberOfNeighbors,
                                                 int searchLinkLevel,
                                                 int targetLinkLevel,
                                                 LODNetworkConstraint constraint,
                                                 LODGoalNode goalNodeFilter)
                                          throws LODNetworkException

Finds the nearest reaching neighbors to the specified end point candidates.

Parameters:

endPoints - end point candidates on the network

numberOfNeighbors - number of neighbors to be returned

searchLinkLevel - the preferred link level to search for neighbors

targetLinkLevel - maximum incoming link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the nearest reaching neighbors to the end point candidates

Throws:

LODNetworkException

nearestReachingNeighborsLight

public LogicalLightSubPath[] nearestReachingNeighborsLight(PointOnNet[] endPoints,
                                                           int numberOfNeighbors,
                                                           int searchLinkLevel,
                                                           int targetLinkLevel,
                                                           LODNetworkConstraint constraint,
                                                           LODGoalNode goalNodeFilter)
                                                    throws LODNetworkException

Finds the nearest reaching neighbors to the specified end point candidates.

Parameters:

endPoints - end point candidates on the network

numberOfNeighbors - number of neighbors to be returned

searchLinkLevel - the preferred link level to search for neighbors

targetLinkLevel - maximum incoming link level of the neighbors

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the nearest reaching neighbors to the specified end point candidates

Throws:

LODNetworkException

withinCost

public LogicalSubPath[] withinCost(PointOnNet startPoint,
                                   double cost,
                                   LODNetworkConstraint constraint,
                                   LODGoalNode goalNodeFilter)
                            throws LODNetworkException

Finds the nodes within the specified cost from the start point. Both the search and the target link levels are set to the lowest link level.

Parameters:

startPoint - start point

cost - cost bound

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the target nodes from the start point

Throws:

LODNetworkException

withinCost

public LogicalSubPath[] withinCost(PointOnNet startPoint,
                                   double cost,
                                   int targetLinkLevel,
                                   LODNetworkConstraint constraint,
                                   LODGoalNode goalNodeFilter)
                            throws LODNetworkException

Finds the nodes within the specified cost from the start point. The search uses the lowest link level.

Parameters:

startPoint - start point

cost - cost bound

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the target nodes from the start point

Throws:

LODNetworkException

withinCost

public LogicalSubPath[] withinCost(PointOnNet startPoint,
                                   double cost,
                                   int searchLinkLevel,
                                   int targetLinkLevel,
                                   LODNetworkConstraint constraint,
                                   LODGoalNode goalNodeFilter)
                            throws LODNetworkException

Finds the nodes within the specified cost from the start point.

Parameters:

startPoint - start point

cost - cost bound

searchLinkLevel - the link level to search for targets

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the target nodes from the start point

Throws:

LODNetworkException

withinCost

public LogicalSubPath[] withinCost(PointOnNet[] startPoints,
                                   double cost,
                                   int searchLinkLevel,
                                   int targetLinkLevel,
                                   LODNetworkConstraint constraint,
                                   LODGoalNode goalNodeFilter,
                                   boolean returnBoundaryNodesOnly)
                            throws LODNetworkException

Finds the nodes within the specified cost from the start point candidates.

Parameters:

startPoints - start point candidates

cost - cost bound

searchLinkLevel - the link level to search for targets

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryNodesOnly - whether to return the boundary nodes only

Returns:

paths to the target nodes from the start point

Throws:

LODNetworkException

withinCostLight

public LogicalLightSubPath[] withinCostLight(PointOnNet[] startPoints,
                                             double cost,
                                             int searchLinkLevel,
                                             int targetLinkLevel,
                                             LODNetworkConstraint constraint,
                                             LODGoalNode goalNodeFilter,
                                             boolean returnBoundaryNodesOnly)
                                      throws LODNetworkException

Finds the nodes within the specified cost from the start point candidates.

Parameters:

startPoints - start point candidates

cost - cost bound

searchLinkLevel - the link level to search for targets

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryNodesOnly - whether to return the boundary nodes only

Returns:

paths to the target nodes from the start point

Throws:

LODNetworkException

withinReachingCost

public LogicalSubPath[] withinReachingCost(PointOnNet endPoint,
                                           double cost,
                                           LODNetworkConstraint constraint,
                                           LODGoalNode goalNodeFilter)
                                    throws LODNetworkException

Finds the nodes within the specified cost to the end point. Both the search and the target link levels are set to the lowest link level.

Parameters:

endPoint - end point

cost - cost bound

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the target nodes to the end point

Throws:

LODNetworkException

withinReachingCost

public LogicalSubPath[] withinReachingCost(PointOnNet endPoint,
                                           double cost,
                                           int targetLinkLevel,
                                           LODNetworkConstraint constraint,
                                           LODGoalNode goalNodeFilter)
                                    throws LODNetworkException

Finds the nodes within the specified cost to the end point. The search uses the lowest link level.

Parameters:

endPoint - end point

cost - cost bound

targetLinkLevel - maximum incoming link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the target nodes to the end point

Throws:

LODNetworkException

withinReachingCost

public LogicalSubPath[] withinReachingCost(PointOnNet endPoint,
                                           double cost,
                                           int searchLinkLevel,
                                           int targetLinkLevel,
                                           LODNetworkConstraint constraint,
                                           LODGoalNode goalNodeFilter)
                                    throws LODNetworkException

Finds the nodes within the specified cost to the end point.

Parameters:

endPoint - end point

cost - cost bound

searchLinkLevel - the link level to search for targets

targetLinkLevel - maximum incoming link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the target nodes to the end point

Throws:

LODNetworkException

withinReachingCost

public LogicalSubPath[] withinReachingCost(PointOnNet[] endPoints,
                                           double cost,
                                           int searchLinkLevel,
                                           int targetLinkLevel,
                                           LODNetworkConstraint constraint,
                                           LODGoalNode goalNodeFilter,
                                           boolean returnBoundaryNodesOnly)
                                    throws LODNetworkException

Finds the nodes within the specified cost to the end point candidates.

Parameters:

endPoints - end point candidates

cost - cost bound

searchLinkLevel - the link level to search for targets

targetLinkLevel - maximum incoming link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryNodesOnly - whether to return the boundary nodes only

Returns:

paths from the target nodes to the end point

Throws:

LODNetworkException

withinReachingCostLight

public LogicalLightSubPath[] withinReachingCostLight(PointOnNet[] endPoints,
                                                     double cost,
                                                     int searchLinkLevel,
                                                     int targetLinkLevel,
                                                     LODNetworkConstraint constraint,
                                                     LODGoalNode goalNodeFilter,
                                                     boolean returnBoundaryNodesOnly)
                                              throws LODNetworkException

Finds the nodes within the specified cost to the end points.

Parameters:

endPoints - end points

cost - cost bound

searchLinkLevel - the link level to search for targets

targetLinkLevel - maximum incoming link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryNodesOnly - whether to return the boundary nodes only

Returns:

paths from the target nodes to the end point

Throws:

LODNetworkException

withinCostPolygon

public JGeometry withinCostPolygon(PointOnNet[] startPoints,
                                   double cost,
                                   LODNetworkConstraint constraint,
                                   LODGoalNode goalNodeFilter)
                            throws LODNetworkException

Returns the polygon covering the nodes, links or partial links that are within the given cost from the start point candidates.

Parameters:

startPoints - start point candidates

cost - cost range

constraint - network constraint

goalNodeFilter - goal node filter

Returns:

Throws:

LODNetworkException

withinReachingCostPolygon

public JGeometry withinReachingCostPolygon(PointOnNet[] endPoints,
                                           double cost,
                                           LODNetworkConstraint constraint,
                                           LODGoalNode goalNodeFilter)
                                    throws LODNetworkException

Returns the polygon covering the nodes, links or partial links that are within the given cost to the end point candidates.

Parameters:

endPoints - end point candidates

cost - cost range

constraint - network constraint

goalNodeFilter - goal node filter

Returns:

Throws:

LODNetworkException

traceOut

public LogicalSubPath[] traceOut(PointOnNet startPoint,
                                 double cost,
                                 LODNetworkConstraint constraint,
                                 LODGoalNode goalNodeFilter)
                          throws LODNetworkException

Finds the nodes and partial links within the specified cost from the start point. Both the search and the target link levels are set to the lowest link level.

Parameters:

startPoint - start point

cost - cost bound

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the target nodes and links from the start point

Throws:

LODNetworkException

traceOut

public LogicalSubPath[] traceOut(PointOnNet startPoint,
                                 double cost,
                                 int targetLinkLevel,
                                 LODNetworkConstraint constraint,
                                 LODGoalNode goalNodeFilter)
                          throws LODNetworkException

Finds the nodes and partial links within the specified cost from the start point. The search uses the lowest link level.

Parameters:

startPoint - start point

cost - cost bound

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the target nodes and links from the start point

Throws:

LODNetworkException

traceOut

public LogicalSubPath[] traceOut(PointOnNet startPoint,
                                 double cost,
                                 int searchLinkLevel,
                                 int targetLinkLevel,
                                 LODNetworkConstraint constraint,
                                 LODGoalNode goalNodeFilter)
                          throws LODNetworkException

Finds the nodes and partial links within the specified cost from the start point.

Parameters:

startPoint - start point

cost - cost bound

searchLinkLevel - the link level to search on

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths to the target nodes and links from the start point

Throws:

LODNetworkException

traceOut

public LogicalSubPath[] traceOut(PointOnNet[] startPoints,
                                 double cost,
                                 int searchLinkLevel,
                                 int targetLinkLevel,
                                 LODNetworkConstraint constraint,
                                 LODGoalNode goalNodeFilter,
                                 boolean returnBoundaryPointsOnly)
                          throws LODNetworkException

Finds the nodes and partial links within the specified cost from the start point candidates.

Parameters:

startPoints - start points

cost - cost bound

searchLinkLevel - the link level to search on

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryPointsOnly - whether to return boundary points only

Returns:

paths to the target nodes and links from the start point candidates

Throws:

LODNetworkException

traceOutLight

public LogicalLightSubPath[] traceOutLight(PointOnNet[] startPoints,
                                           double cost,
                                           int searchLinkLevel,
                                           int targetLinkLevel,
                                           LODNetworkConstraint constraint,
                                           LODGoalNode goalNodeFilter,
                                           boolean returnBoundaryPointsOnly)
                                    throws LODNetworkException

Finds the nodes and partial links within the specified cost from the start points.

Parameters:

startPoints - start points

cost - cost bound

searchLinkLevel - the link level to search on

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryPointsOnly - whether to return boundary points only

Returns:

paths to the target nodes and links from the start point candidates

Throws:

LODNetworkException

traceIn

public LogicalSubPath[] traceIn(PointOnNet endPoint,
                                double cost,
                                LODNetworkConstraint constraint,
                                LODGoalNode goalNodeFilter)
                         throws LODNetworkException

Finds the nodes and partial links within the specified cost to the end point. Both the search and the target link levels are set to the lowest link level.

Parameters:

endPoint - end point

cost - cost bound

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the target nodes and links to the start point

Throws:

LODNetworkException

traceIn

public LogicalSubPath[] traceIn(PointOnNet endPoint,
                                double cost,
                                int targetLinkLevel,
                                LODNetworkConstraint constraint,
                                LODGoalNode goalNodeFilter)
                         throws LODNetworkException

Finds the nodes and partial links within the specified cost to the end point. The search uses the lowest link level.

Parameters:

endPoint - end point

cost - cost bound

targetLinkLevel - maximum incoming link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the target nodes and links to the start point

Throws:

LODNetworkException

traceIn

public LogicalSubPath[] traceIn(PointOnNet endPoint,
                                double cost,
                                int searchLinkLevel,
                                int targetLinkLevel,
                                LODNetworkConstraint constraint,
                                LODGoalNode goalNodeFilter)
                         throws LODNetworkException

Finds the nodes and partial links within the specified cost to the end point.

Parameters:

endPoint - end point

cost - cost bound

searchLinkLevel - the link level to search on

targetLinkLevel - maximum incoming link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

Returns:

paths from the target nodes and links to the end point

Throws:

LODNetworkException

traceIn

public LogicalSubPath[] traceIn(PointOnNet[] endPoints,
                                double cost,
                                int searchLinkLevel,
                                int targetLinkLevel,
                                LODNetworkConstraint constraint,
                                LODGoalNode goalNodeFilter,
                                boolean returnBoundaryPointsOnly)
                         throws LODNetworkException

Finds the nodes and partial links within the specified cost to the end point candidates.

Parameters:

endPoints - end point candidates

cost - cost bound

searchLinkLevel - the link level to search on

targetLinkLevel - maximum incoming link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryPointsOnly - whether to return boundary points only

Returns:

paths from the target nodes and links to the end point candidates

Throws:

LODNetworkException

traceInLight

public LogicalLightSubPath[] traceInLight(PointOnNet[] startPoints,
                                          double cost,
                                          int searchLinkLevel,
                                          int targetLinkLevel,
                                          LODNetworkConstraint constraint,
                                          LODGoalNode goalNodeFilter,
                                          boolean returnBoundaryPointsOnly)
                                   throws LODNetworkException

Finds the nodes and partial links within the specified cost to the end point candidates.

Parameters:

startPoints - start point candidates

cost - cost bound

searchLinkLevel - the link level to search on

targetLinkLevel - maximum outgoing link level of the targets

constraint - network constraint

goalNodeFilter - goal node implementation

returnBoundaryPointsOnly - whether to return boundary points only

Returns:

paths to the target nodes and links from the end point candidates

Throws:

LODNetworkException

findConnectedNodes

public OrderedLongSet findConnectedNodes(int searchMethod,
                                         long nodeId,
                                         int linkLevel,
                                         LODNetworkConstraint constraint,
                                         LODGoalNode goalNode)
                                  throws LODNetworkException

Finds the nodes connected to the specified node.

Parameters:

searchMethod - search method. It can take the following values:

• NetworkAnalyst.BREADTH_FIRST_SEARCH, or
• NetworkAnalyst.DEPTH_FIRST_SEARCH.

  nodeId - node ID

  linkLevel - maximum link level to search on

  Returns:

  node IDs connected to the specified node ID

  Throws:

  LODNetworkException

findReachableNodes

public OrderedLongSet findReachableNodes(int searchMethod,
                                         long startNodeId,
                                         int linkLevel,
                                         LODNetworkConstraint constraint,
                                         LODGoalNode goalNode)
                                  throws LODNetworkException

Finds the nodes reachable from the specified node.

Parameters:

searchMethod - search method. It can take the following values:

• NetworkAnalyst.BREADTH_FIRST_SEARCH, or
• NetworkAnalyst.DEPTH_FIRST_SEARCH.

  startNodeId - start node ID

  linkLevel - maximum link level to search on

  Returns:

  node IDs reachable from the specified node ID

  Throws:

  LODNetworkException

findReachingNodes

public OrderedLongSet findReachingNodes(int searchMethod,
                                        long endNodeId,
                                        int linkLevel,
                                        LODNetworkConstraint constraint,
                                        LODGoalNode goalNode)
                                 throws LODNetworkException

Finds the nodes that can reach the specified node.

Parameters:

searchMethod - search method. It can take the following values:

• NetworkAnalyst.BREADTH_FIRST_SEARCH, or
• NetworkAnalyst.DEPTH_FIRST_SEARCH.

  endNodeId - end node ID

  linkLevel - maximum link level to search on

  Returns:

  node IDs that can reach the specified node ID

  Throws:

  LODNetworkException

isReachable

public boolean isReachable(long startNodeId,
                           long endNodeId,
                           int linkLevel,
                           LODNetworkConstraint constraint)
                    throws LODNetworkException

Checks whether there is a path from the start node to the end node using the specified link level for long-haul search.

Parameters:

startNodeId - start node ID

endNodeId - end node ID

linkLevel - maximum link level to search on

Returns:

true, if there exists a path from the start node to the end node; false, otherwise.

Throws:

LODNetworkException

findConnectedComponents

public OrderedLongSet[] findConnectedComponents(int linkLevel)
                                         throws LODNetworkException

Finds the connected components for the specified link level.

Parameters:

linkLevel - maximum link level to search on

Returns:

the connected components

Throws:

LODNetworkException

findConnectedComponentsInPartition

public int findConnectedComponentsInPartition(int partitionId,
                                              int linkLevel,
                                              int startComponentId,
                                              java.util.ArrayList<oracle.spatial.network.lod.AnalysisUtility.NodeComponent> nodeComponentArray)
                                       throws LODNetworkException

Finds the connected components for the specified link level.

Parameters:

linkLevel - maximum link level to search on

Returns:

the connected components

Throws:

LODNetworkException

shortestPathDijkstra

public LogicalSubPath shortestPathDijkstra(PointOnNet startPoint,
                                           PointOnNet endPoint,
                                           LODNetworkConstraint constraint)
                                    throws LODNetworkException

Finds the shortest path using Dijkstra algorithm and the analyst's link level selector specified by the user.

Parameters:

startPoint - start point on the network

endPoint - end point on the network

constraint - network constraint

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathDijkstraMaxLevel

public LogicalSubPath shortestPathDijkstraMaxLevel(PointOnNet startPoint,
                                                   PointOnNet endPoint,
                                                   LODNetworkConstraint constraint)
                                            throws LODNetworkException

Finds the shortest path using Dijkstra algorithm where the long-haul path is computed on the maximum link level.

Parameters:

startPoint - start point

endPoint - end point

constraint - network constraint

Returns:

shortest path from the start node to the end node

Throws:

LODNetworkException

shortestPathDijkstra

public LogicalSubPath shortestPathDijkstra(PointOnNet startPoint,
                                           PointOnNet endPoint,
                                           int searchLinkLevel,
                                           LODNetworkConstraint constraint)
                                    throws LODNetworkException

Finds the shortest path using Dijkstra algorithm with static link level selector.

Parameters:

startPoint - start point on the network

endPoint - end point on the network

constraint - network constraint

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathDijkstra

public LogicalSubPath shortestPathDijkstra(PointOnNet[] startPoints,
                                           PointOnNet[] endPoints,
                                           int searchLinkLevel,
                                           LODNetworkConstraint constraint)
                                    throws LODNetworkException

Finds the shortest path using Dijkstra algorithm with static link level selector.

Parameters:

startPoints - candidate start points on the network

endPoints - candidate end points on the network

constraint - network constraint

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathDijkstra

public LogicalSubPath shortestPathDijkstra(PointOnNet[] startPoints,
                                           PointOnNet[] endPoints,
                                           int searchLinkLevel,
                                           int maxHighLevelNodesToConsider,
                                           LODNetworkConstraint constraint)
                                    throws LODNetworkException

Finds the shortest path using Dijkstra algorithm with static link level selector.

Parameters:

startPoints - candidate start points on the network

endPoints - candidate end points on the network

constraint - network constraint

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathAStar

public LogicalSubPath shortestPathAStar(PointOnNet startPoint,
                                        PointOnNet endPoint,
                                        LODNetworkConstraint constraint,
                                        HeuristicCostFunction hcf,
                                        double[] costThresholds)
                                 throws LODNetworkException

Finds the shortest path using A* algorithm using dynamic link level selector. The prefered search link level of the dynamic link level selector is set to the maximum link level of the network.

Parameters:

startPoint - start point on the network

endPoint - end point on the network

constraint - network constraint

hcf - Heuristic cost function implementation

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathAStar

public LogicalSubPath shortestPathAStar(PointOnNet startPoint,
                                        PointOnNet endPoint,
                                        int searchLinkLevel,
                                        LODNetworkConstraint constraint,
                                        HeuristicCostFunction hcf,
                                        double[] costThresholds)
                                 throws LODNetworkException

Finds the shortest path using A* algorithm using dynamic link level selector.

Parameters:

startPoint - start point on the network

endPoint - end point on the network

searchLinkLevel - prefered link level to compute long-haul path

constraint - network constraint

hcf - Heuristic cost function implementation

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathAStar

public LogicalSubPath shortestPathAStar(PointOnNet startPoint,
                                        PointOnNet endPoint,
                                        LODNetworkConstraint constraint,
                                        HeuristicCostFunction hcf,
                                        LinkLevelSelector lls)
                                 throws LODNetworkException

Finds the shortest path using A* algorithm using dynamic link level selector of this NetworkAnalyst.

Parameters:

startPoint - start point on the network

endPoint - end point on the network

constraint - network constraint

hcf - Heuristic cost function implementation

lls - link level selector to be used in A* algorithm

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathAStar

public LogicalSubPath shortestPathAStar(PointOnNet[] startPoints,
                                        PointOnNet[] endPoints,
                                        LODNetworkConstraint constraint,
                                        HeuristicCostFunction hcf,
                                        LinkLevelSelector lls)
                                 throws LODNetworkException

Finds the shortest path using A* algorithm with dynamic link level selector.

Parameters:

startPoints - start point candidates on the network

endPoints - end point on candidates the network

constraint - network constraint

hcf - Heuristic cost function implementation

lls - link level selector to be used in A* algorithm

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

shortestPathHierarchical

public LogicalSubPath shortestPathHierarchical(PointOnNet[] startPoints,
                                               PointOnNet[] endPoints,
                                               int searchLinkLevel,
                                               int maxHighLevelNodesToConsider,
                                               LODNetworkConstraint constraint,
                                               ShortestPath algorithm)
                                        throws LODNetworkException

Finds the shortest path from a point on the start link to the end node.

Parameters:

startPoints - start point candidates on the network

endPoints - end point candidates on the network

maxHighLevelNodesToConsider - maximum high level nodes to consider

constraint - network constraint

Returns:

shortest path from the start point to the end point

Throws:

LODNetworkException

mcst

public long[] mcst(int linkLevel,
                   LODNetworkConstraint constraint,
                   NetworkUpdate tmpNetworkUpdate)
            throws LODNetworkException

Returns the link IDs of the minimum-spanning-tree.

Parameters:

linkLevel - link level

tmpNetworkUpdate - temporary network update

Returns:

link IDs of the minimum-spanning-tree

Throws:

LODNetworkException

tsp

public TspPath tsp(PointOnNet[][] pointsToVisit,
                   TSP.TourFlag tourFlag,
                   int linkLevel,
                   LODNetworkConstraint constraint)
            throws LODNetworkException

Returns the traveling salesman tour for the specified points.

Parameters:

pointsToVisit - points to visit on the tour

tourFlag - a flag indicating whether the tour should be open or closed, and if the tour is open, whether the tour should have fixed start or end point.

linkLevel - link level

constraint - network constraint

Returns:

traveling salemans tour

Throws:

LODNetworkException

tsp

public TspPath tsp(PointOnNet[][] pointsToVisit,
                   TSP.TourFlag tourFlag,
                   int linkLevel,
                   LODNetworkConstraint constraint,
                   TSP algorithm)
            throws LODNetworkException

Returns the traveling salesman tour for the specified points.

Parameters:

pointsToVisit - points to visit on the tour.

tourFlag - a flag indicating whether the tour should be open or closed, and if the tour is open, whether the tour should have fixed start or end point.

linkLevel - link level

constraint - network constraint

algorithm - tsp algorithm

Returns:

traveling salemans tour

Throws:

LODNetworkException

kShortestPaths

public LogicalSubPath[] kShortestPaths(PointOnNet[] startPoint,
                                       PointOnNet[] endPoint,
                                       int k,
                                       LODNetworkConstraint constraint,
                                       KShortestPaths kspAlgorithm)
                                throws LODNetworkException

Returns K shortest loopless paths from the start point candiates to the end point candidates.

Parameters:

startPoint - start point candidates

endPoint - end point candidates

k - number of loopless paths to be returned

constraint - network constraint

Returns:

K shortest loopless paths from the start point to the end point

Throws:

LODNetworkException

networkBuffer

public NetworkBuffer networkBuffer(PointOnNet[] startPoints,
                                   double cost,
                                   LODNetworkConstraint constraint)
                            throws LODNetworkException

Computes network buffer within the specified cost from the start point candidates.

Parameters:

startPoints - start point candidates

cost - cost range of the network buffer

constraint - network constraint

Returns:

network buffer within the specified cost from the start point candidates

Throws:

LODNetworkException

reachingNetworkBuffer

public NetworkBuffer reachingNetworkBuffer(PointOnNet[] endPoints,
                                           double cost,
                                           LODNetworkConstraint constraint)
                                    throws LODNetworkException

Computes network buffer within the specified cost to the end point candidates.

Parameters:

endPoints - end point candidates

cost - cost range of the network buffer

constraint - network constraint

Returns:

network buffer within the specified cost to the end point candidates

Throws:

LODNetworkException