TransportationAnalystProvider

All Known Implementing Classes:

ArcGISRestNetworkAnalystProvider, RestTransportationAnalystProvider, UGCTransportationAnalystProvider
```
public interface TransportationAnalystProvider
```
The interface of SuperMap transportation network analysis service providers.

SuperMap transportation network analysis service providers provide SuperMap services related to transportation network analysis, encapsulating all the GIS functions related to transportation network analysis.

Method Summary

Methods
Modifier and Type	Method and Description
`BurstAnalyseResult`	`burstAnalyseFromEdge(int[] sourceNodeIDs, int edgeID, FacilityAnalystParameter parameter)`
`BurstAnalyseResult`	`burstAnalyseFromNode(int[] sourceNodeIDs, int nodeID, FacilityAnalystParameter parameter)`
`double[][]`	`computeWeightMatrix(int[] nodeIDs, TransportationAnalystParameter parameter)` Gets a cost matrix according to the network analysis parameter.The matrix is a 2D double array used to store the resource cost between any two points.
`double[][]`	`computeWeightMatrix(Point2D[] points, TransportationAnalystParameter parameter)` Gets a cost matrix according to the network analysis parameter.The matrix is a 2D double array used to store the resource cost between any two points.
`ClosestFacilityPaths<java.lang.Integer>`	`findClosestFacility(int[] facilityIDs, int eventID, int expectFacilityCount, boolean fromEvent, double maxWeight, TransportationAnalystParameter parameter)` Closest facility analysis, in which events are represented by network node IDs.
`ClosestFacilityPaths<Point2D>`	`findClosestFacility(Point2D[] facilityPoints, Point2D eventPoint, int expectFacilityCount, boolean fromEvent, double maxWeight, TransportationAnalystParameter parameter)` Closest facility analysis, in which events are represented by point coordinates.
`FacilityAnalyst2DResult`	`findConnectedEdgesFromEdges(int[] edgeIDs, boolean returnFeatures, boolean connected)` Finds the connected edges for the edges specified with ID array.
`FacilityAnalyst2DResult`	`findConnectedEdgesFromNodes(int[] nodeIDs, boolean returnFeatures, boolean connected)` Finds the connected or unconnected edges for the nodes specified with ID array.
`FacilityAnalyst2DResult`	`findCriticalFacilitiesDownFromEdge(int[] sourceNodeIDs, int edgeID, FacilityAnalystParameter parameter)`
`FacilityAnalyst2DResult`	`findCriticalFacilitiesDownFromNode(int[] sourceNodeIDs, int nodeID, FacilityAnalystParameter parameter)`
`FacilityAnalyst2DResult`	`findCriticalFacilitiesUpFromEdge(int[] sourceNodeIDs, int edgeID, FacilityAnalystParameter parameter)`
`FacilityAnalyst2DResult`	`findCriticalFacilitiesUpFromNode(int[] sourceNodeIDs, int nodeID, FacilityAnalystParameter parameter)`
`LocationAnalystResult`	`findLocation(LocationAnalystParameter parameter)` The location-allocation analysis.
`MTSPPaths<java.lang.Integer>`	`findMTSPPath(int[] nodeIDs, int[] centerIDs, boolean hasLeastTotalCost, TransportationAnalystParameter parameter)` The multiple traveling salesmen analysis (logistics).
`MTSPPaths<Point2D>`	`findMTSPPath(Point2D[] points, Point2D[] centerPoints, boolean hasLeastTotalCost, TransportationAnalystParameter parameter)` The multiple traveling salesmen analysis (logistics).
`Paths`	`findPath(int[] nodeIDs, boolean hasLeastEdgeCount, TransportationAnalystParameter parameter)` Optimal path analysis.
`Paths`	`findPath(Point2D[] points, boolean hasLeastEdgeCount, TransportationAnalystParameter parameter)` Optimal path analysis.
`ServiceAreaResults<java.lang.Integer>`	`findServiceArea(int[] centerIDs, double[] weights, boolean isFromCenter, boolean isCenterMutuallyExclusive, TransportationAnalystParameter parameter)` The service area analysis.
`ServiceAreaResults<Point2D>`	`findServiceArea(Point2D[] centerPoints, double[] weights, boolean isFromCenter, boolean isCenterMutuallyExclusive, TransportationAnalystParameter parameter)` The service area analysis.
`TSPPaths`	`findTSPPath(int[] nodeIDsToVisit, boolean endNodeAssigned, TransportationAnalystParameter parameter)` The traveling salesmen analysis.
`TSPPaths`	`findTSPPath(Point2D[] pointsToVisit, boolean endNodeAssigned, TransportationAnalystParameter parameter)` The traveling salesmen analysis.
`java.lang.String`	`getNetworkDataName()` Gets the network data name.
`PrjCoordSys`	`getPrjCoordSys()` Gets the projection information of the network data.
`java.lang.String[]`	`getTurnWeightNames()` Gets the name of the turn weight field in a network dataset.
`java.lang.String[]`	`getWeightNames()` Gets the name of the weight field in a network dataset.
`boolean`	`reloadModel()` Reloads the network model.
`FacilityAnalyst2DResult`	`traceDownFromEdge(int edgeID, FacilityAnalystParameter parameter)` Traces down with the specified edge ID, ie., finding the downstream of the specified edge, and returning the edges and nodes the downstream includes and the total cost
`FacilityAnalyst2DResult`	`traceDownFromNode(int nodeID, FacilityAnalystParameter parameter)` Traces down with the specified node ID, ie., finding the downstream of the specified node, and returning the edges and nodes the downstream includes and the total cost
`FacilityAnalyst2DResult`	`traceUpFromEdge(int edgeID, FacilityAnalystParameter parameter)` Traces up with the specified edge ID, ie., finding the upstream of the specified edge, and returning the edges and nodes the upstream includes and the total cost
`FacilityAnalyst2DResult`	`traceUpFromNode(int nodeID, FacilityAnalystParameter parameter)` Traces up with the specified node ID, ie., finding the upstream of the specified node, and returning the edges and nodes the upstream includes and the total cost
`double`	`updateEdgeWeight(int edgeID, int fromNodeID, int toNodeID, java.lang.String weightField, double weight)` Updates the edge weight.
`double`	`updateTurnNodeWeight(int nodeID, int fromEdgeID, int toEdgeID, java.lang.String turnWeightField, double weight)` Updates the weight of turn node.

- Method Detail
  - computeWeightMatrix
```
double[][] computeWeightMatrix(int[] nodeIDs,
                             TransportationAnalystParameter parameter)
```
    Gets a cost matrix according to the network analysis parameter.The matrix is a 2D double array used to store the resource cost between any two points.
    
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    nodeIDs - The ID set of the points used to calculate the cost matrix.
    
    Returns:
    
    The 2D double array used to store the resource cost between any two points.
  - computeWeightMatrix
```
double[][] computeWeightMatrix(Point2D[] points,
                             TransportationAnalystParameter parameter)
```
    Gets a cost matrix according to the network analysis parameter.The matrix is a 2D double array used to store the resource cost between any two points.
    
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    points - The points to calculate the cost matrix.
    
    Returns:
    
    The 2D double array used to store the resource cost between any two points.
  - findClosestFacility
```
ClosestFacilityPaths<java.lang.Integer> findClosestFacility(int[] facilityIDs,
                                                          int eventID,
                                                          int expectFacilityCount,
                                                          boolean fromEvent,
                                                          double maxWeight,
                                                          TransportationAnalystParameter parameter)
```
    Closest facility analysis, in which events are represented by network node IDs.
    
    The closest facility analysis is to find one or more facilities to which the cost from the event point is the least among the given event point and a set of facilities. The result is the optimal path from the event point to the facility (or from the facility to the event point).
    - The facility: the basic element of the closest facility analysis, such as the school, supermarket, gas station, etc.
    - The event: the basic element of the closest facility analysis--the location that needs service facilities.
    For example: A traffic accident happens in the street, and we need to find out hospitals that are able to be reached within 10 minutes, with hospitals out of 10 minutes' ride out of consideration.In this instance, the accident location is an event, the hospitals around are the facilities.
    
    In the closest facility analysis, there are two methods to specify the event.One is to specify according to the coordinates, and the other one is to specify according to network node ID, ie., specify the network node as the event. This method specifies the event by using node ID.
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    facilityIDs - The facility node ID array. Required.
    
    eventID - The event node coordinate. Required.
    
    expectFacilityCount - The amount of the expected facilities to search. Optional. The default value is 1.
    
    fromEvent - Whether to start the search from the event. Optional. The default value is false.
    
    maxWeight - The searching radius. Required. It has the same unit as the weight field in parameter (the general parameter for transportation network analysis). If the search is based on the entire network, set this parameter to 0.
    
    Returns:
    
    The result path set of closest facility analysis.
  - findClosestFacility
```
ClosestFacilityPaths<Point2D> findClosestFacility(Point2D[] facilityPoints,
                                                Point2D eventPoint,
                                                int expectFacilityCount,
                                                boolean fromEvent,
                                                double maxWeight,
                                                TransportationAnalystParameter parameter)
```
    Closest facility analysis, in which events are represented by point coordinates.
    
    The closest facility analysis is to find one or more facilities to which the cost from the event point is the least among the given event point and a set of facilities. The result is the optimal path from the event point to the facility (or from the facility to the event point).
    - The facility: the basic element of the closest facility analysis, such as the school, supermarket, gas station, etc.
    - The event: the basic element of the closest facility analysis--the location that needs service facilities.
    For example: A traffic accident happens in the street, and we need to find out hospitals that are able to be reached within 10 minutes, with hospitals out of 10 minutes' ride out of consideration.In this instance, the accident location is an event, the hospitals around are the facilities.
    
    In the closest facility analysis, there are two methods to specify the event.One is to specify according to the coordinates, and the other one is to specify according to network node ID, ie., specify the network node as the event. This method specifies the event by using coordinate of point.
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    facilityPoints - The coordinates array of facility nodes. Required.
    
    eventPoint - The event node coordinate. Required.
    
    expectFacilityCount - The amount of the expected facilities to search. Optional. The default value is 1.
    
    fromEvent - Whether to start the search from the event. Optional. The default value is false.
    
    maxWeight - The searching radius. It has the same unit as the weight field in parameter (the general parameter for transportation network analysis). If the search is based on the entire network, set this parameter to 0.
    
    Returns:
    
    The result path set of closest facility analysis.
  - findLocation
```
LocationAnalystResult findLocation(LocationAnalystParameter parameter)
```
    The location-allocation analysis.
    
    The location-allocation analysis is to determine one or more best or optimal positions to build facilities, which makes facilities use one of the most economic and efficient way to provide service or commodity. Location-Allocation is not only o find the best locations, it also needs to consider how many resource each location should provide based on the demands. So it's called Location-Allocation.
    
    In location-allocation analysis, the SupplyCenter and analysis model are set with LocationAnalystParameter. Please see LocationAnalystParameter class for more detailes.
    
    In location-allocation analysis, all demand points are network nodes. Except for the network nodes corresponding to the supply center points, all network nodes demand points. To exclude certain network nodes, you can set the nodes as barriers.
    
    Example: 7 post offices will be built in an area with 15 candidate locations, represented by blue rectangles in the figure 1 below, that has no post offices. Which locations will be selected to build post offices depending on the following two conditions: no more than 30 minutes by walk for residents and the amount of residents a post office can serve is limited. Based on the two conditions, location-allocation analysis will give optimal locations and points out the service area of each post office. As shown is the figure 2 below, the red points represent the 7 selected locations for setting up post offices.
    
    Note: All network nodes of the following two network datasets are regarded as the residential areas and will participate in the location-allocation analysis. The resident number in the residential area is the amount of services the residential area needs.
    
    Figure 1. A diagram of network dataset to analyze and 15 candidate center points
    
    Figure 2. A diagram of the location-allocation analysis result
    
    Parameters:
    
    datasourceName - The datasource name of network dataset belongs to.
    
    datasetName - The network dataset name.
    
    parameter - The parameter object for location-allocation analysis.
    
    Returns:
    
    The location-allocation analysis result.
  - findMTSPPath
```
MTSPPaths<java.lang.Integer> findMTSPPath(int[] nodeIDs,
                                        int[] centerIDs,
                                        boolean hasLeastTotalCost,
                                        TransportationAnalystParameter parameter)
```
    The multiple traveling salesmen analysis (logistics). The logistics center is represented by the ID array of network nodes.
    
    The multiple traveling salesmen analysis is also called logistics. It means with the M centers and N destinations (M, N are both greater than 0) in network dataset, to find the economic and effective delivering path from the supply center to destination, and show the corresponding walk path.
    
    Logistics refers to the problem that how to determine the order of the destinations to be delivered and the best route so as to minimize the total cost of the route.
    
    The MTSP result will list each distribution center and its delivery destinations, the order of the delivery for the destinations and the delivery routes. So as to make the delivery cost for each center at a average level, or minimize the total cost of all the centers.
    
    Example: There are 50 newspaper retailers (destinations), and 4 newspaper supply locations (supply centers). Now we need to find out the optimal path to deliver the newspaper to the retailers, which is a logistics problem. The following figure demonstrates this example.
    
    Figure 1 shows the analysis result, where the big circles represent the 4 newspaper supply locations (supply centers) and the small circles represent the newspaper retailers (destinations). Each color represents a solution for one supply center, including its destinations, the visited order and the delivery route. Figure 2 shows the delivery solution of Supply Center 2. Blue circles with numbers are destinations (18 in total) of the Supply Center 2. Newspaper will be delivered in the order indicated by the numbers on the blue circles, with the delivery man starting at the supply center, passing through 1, 2, etc., and then go back to the supply center.
    
    Figure 1. The result of multiple traveling salesmen analysis
    
    Figure 2. The delivery solution for Supply Center 2
    
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    nodeIDs - The destination node ID array. Required.
    
    centerIDs - The ID array of Centers, ie., specifies the centers in the form of the node ID array of the network dataset. Required.
    
    hasLeastTotalCost - Whether the delivery solution has the least total cost. Optional. The default is false, indicating to adopt the locally optimal solution. If set to true, the solution with the least total cost will be adopted.
    In the solution with the least total cost, the cost of certain supply centers may be far more than some other supply centers. The locally optimal cost solution balances the cost of all supply centers to make them have similar cost, but the total cost may not be the least.
    
    Returns:
    
    The result set of multiple traveling salesmen analysis.
  - findMTSPPath
```
MTSPPaths<Point2D> findMTSPPath(Point2D[] points,
                              Point2D[] centerPoints,
                              boolean hasLeastTotalCost,
                              TransportationAnalystParameter parameter)
```
    The multiple traveling salesmen analysis (logistics). The logistics center is represented by the coordinates of network nodes.
    
    The multiple traveling salesmen analysis is also called logistics. It means with the M centers and N destinations (M, N are both greater than 0) in network dataset, to find the economic and effective delivering path from the supply center to destination, and show the corresponding walk path.
    
    Logistics refers to the problem that how to determine the order of the destinations to be delivered and the best route so as to minimize the total cost of the route.
    
    The MTSP result will list each distribution center and its delivery destinations, the order of the delivery for the destinations and the delivery routes. So as to make the delivery cost for each center at a average level, or minimize the total cost of all the centers.
    
    Example: There are 50 newspaper retailers (destinations), and 4 newspaper supply locations (supply centers). Now we need to find out the optimal path to deliver the newspaper to the retailers, which is a logistics problem. The following figure demonstrates this example.
    
    Figure 1 shows the analysis result, where the big circles represent the 4 newspaper supply locations (supply centers) and the small circles represent the newspaper retailers (destinations). Each color represents a solution for one supply center, including its destinations, the visited order and the delivery route. Figure 2 shows the delivery solution of Supply Center 2. Blue circles with numbers are destinations (18 in total) of the Supply Center 2. Newspaper will be delivered in the order indicated by the numbers on the blue circles, with the delivery man starting at the supply center, passing through 1, 2, etc., and then go back to the supply center.
    
    Figure 1. The result of multiple traveling salesmen analysis
    
    Figure 2. The delivery solution for Supply Center 2
    
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    points - The points array of the destinations represented by coordinates. Required.
    
    centerPoints - The points array of the supply centers represented by coordinates, ie., specify the supply centers by using the coordinates of their points. Required.
    
    hasLeastTotalCost - Whether the delivery solution has the least total cost. Optional. The default is false, indicating to adopt the locally optimal solution. If set to true, the solution with the least total cost will be adopted.
    In the solution with the least total cost, the cost of certain supply centers may be far more than some other supply centers. The locally optimal cost solution balances the cost of all supply centers to make them have similar cost, but the total cost may not be the least.
    
    Returns:
    
    The result set of multiple traveling salesmen analysis.
  - findPath
```
Paths findPath(int[] nodeIDs,
             boolean hasLeastEdgeCount,
             TransportationAnalystParameter parameter)
```
    Optimal path analysis.
    
    The optimal path analysis aims at finding out the path with the minimum impedance in the network dataset with the given N points (N is greater than 2). The "minimum impedance" can refer to the shortest time, the minimum cost, the best scenery, the best road condition, passing the least bridges, passing the least toll-stations, passing the most countries, etc.
    
    This method returns a path with the minimum impedance passing all the N points in a certain order.
    
    Example: Suppose there are four nodes, 1, 2, 3, and 4, to be accessed in order. To find the optimal path needs to first find the optimal paths between node 1 and 2, node 2 and 3, as well as node 3 and 4, represented with R1_2, R2_3, R3_4, respectively. Then the optimal path passing nodes 1, 2, 3, and 4 in order is R which equals to R1_2 + R2_3 + R3_4.
    
    Similarities and differences between optimal path analysis and traveling salesmen analysis:
    - Similarities: Both of them aim at finding out the least cost path by traversing network nodes.
    - The difference: They handle the order in which the points are visited differently. In an optimal path analysis, the points have to be visited in a specified order. Whereas in a traveling salesmen analysis, the best order for visiting the points is to be determined and is not necessarily the same with any specified order. For detailed information on traveling salesmen analysis, please see the #findTSPPath(String,String,TransportationAnalystParameter,boolean).
    }
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    nodeIDs - The node ID array to pass through. This parameter is required.
    
    hasLeastEdgeCount - Whether the path has the least edges. This parameter is optional. The default is false.
    The path with the least number of edges may not be the shortest path. As shown in the figure below, the green path is the path with the least edges, with this parameter set to true, and the yellow path is the result path, with this parameter set to false.
    
    Returns:
    
    The optimal path analysis result set, which includes only one element now.
  - findPath
```
Paths findPath(Point2D[] points,
             boolean hasLeastEdgeCount,
             TransportationAnalystParameter parameter)
```
    Optimal path analysis.
    
    The optimal path analysis aims at finding out the path with the minimum impedance in the network dataset with the given N points (N is greater than 2). The "minimum impedance" can refer to the shortest time, the minimum cost, the best scenery, the best road condition, passing the least bridges, passing the least toll-stations, passing the most countries, etc.
    
    This method returns a path with the minimum impedance passing all the N points in a certain order.
    
    Example: Suppose there are four nodes, 1, 2, 3, and 4, to be accessed in order. To find the optimal path needs to first find the optimal paths between node 1 and 2, node 2 and 3, as well as node 3 and 4, represented with R1_2, R2_3, R3_4, respectively. Then the optimal path passing nodes 1, 2, 3, and 4 in order is R which equals to R1_2 + R2_3 + R3_4.
    
    Similarities and differences between optimal path analysis and traveling salesmen analysis:
    - Similarities: Both of them aim at finding out the least cost path by traversing network nodes.
    - The difference: They handle the order in which the points are visited differently. In an optimal path analysis, the points have to be visited in a specified order. Whereas in a traveling salesmen analysis, the best order for visiting the points is to be determined and is not necessarily the same with any specified order. For detailed information on traveling salesmen analysis, please see the #findTSPPath(String,String,TransportationAnalystParameter,boolean).
    }
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    points - The coordinate array of the points need to be passed. This parameter is required.
    
    hasLeastEdgeCount - Whether the path has the least edges. This parameter is optional. The default is false.
    The path with the least number of edges may not be the shortest path. As shown in the figure below, the green path is the path with the least edges, with this parameter set to true, and the yellow path is the result path, with this parameter set to false.
    
    Returns:
    
    The optimal path analysis result set, which includes only one element now.
  - findServiceArea
```
ServiceAreaResults<java.lang.Integer> findServiceArea(int[] centerIDs,
                                                    double[] weights,
                                                    boolean isFromCenter,
                                                    boolean isCenterMutuallyExclusive,
                                                    TransportationAnalystParameter parameter)
```
    The service area analysis.
    
    The service area analysis is to find the area the supply center serves in the network.
    
    Service area: The area contains all the accessible edges and nodes, with the specified point as the center. In short, it is the area that a supply location of a specific service serves.
    
    Service area analysis: Calculates the service area for a specified point in the network. For instance, we can calculate the 30-minute service area for a point in the network. In this result service area, the time cost from the point to any point in the service area will be less than 30 minutes.
    
    The following image shows what is the service area analysis result like and what problems the service area analysis solves. The blue circles in the figure below represent the supply center that supplies services. Areas in different colors are service areas of the supply center with different impedances.
    
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    centerIDs - The center ID array. This parameter is required.
    
    weights - The service radius collection. This parameter is required. The collection size is the same as the center count. This parameter identifies the value range that used in the service area analysis. If we set weights[0] to 30.0, it indicates that it shouldn't take more than 30 minutes to get to the 1st supply center from any points of the service area of the 1st point.
    
    isFromCenter - whether to analyze from the supply center point. The parameter is optional. The default is false, which means the analysis doesn't start from the center point.
    Whether to analyze from the center point shows the relation mode between the supply center and the demand points. If the analysis starts from the supply center, it means the supply center actively delivers services to demand points. If the analysis doesn't start from the supply center, the demand point actively gets the services from the supply center and the supply center passively provides the services
    
    For instance, when analyzing the service area of a milk station, isFromCenter needs to be set to true because the milk station actively sends milk to residents. However, when analyzing the service area of a school, isFromCetner needs to be set to false because students actively come to the school to have classes every day.
    
    isCenterMutuallyExclusive - Whether the service areas are mutually exclusive. This parameter is optional. The default is false, which means service areas are not mutually exclusive. If set to true, overlapping service areas will be handled. Note: Supply center mutual exclusion is not supported currently.
    Below shows the effects before and after exclusion handling.
    
    A result without no-overlay processing A result after overlay processing
    
    Returns:
    
    The service area analysis result. It is an array whose size is the same with the number of the supply center. Every element in the array corresponds to the description of a service area of a supply center.
  - findServiceArea
```
ServiceAreaResults<Point2D> findServiceArea(Point2D[] centerPoints,
                                          double[] weights,
                                          boolean isFromCenter,
                                          boolean isCenterMutuallyExclusive,
                                          TransportationAnalystParameter parameter)
```
    The service area analysis.
    
    The service area analysis is to find the area the supply center serves in the network.
    
    Service area: The area contains all the accessible edges and nodes, with the specified point as the center. In short, it is the area that a supply location of a specific service serves.
    
    Service area analysis: Calculates the service area for a specified point in the network. For instance, we can calculate the 30-minute service area for a point in the network. In this result service area, the time cost from the point to any point in the service area will be less than 30 minutes.
    
    The following image shows what is the service area analysis result like and what problems the service area analysis solves. The blue circles in the figure below represent the supply center that supplies services. Areas in different colors are service areas of the supply center with different impedances.
    
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    centerPoints - The points array of the service centers represented by coordinates. Required.
    
    weights - The service radius collection. This parameter is required. The collection size is the same as the center count. This parameter identifies the value range that used in the service area analysis. If we set weights[0] to 30.0, it indicates that it shouldn't take more than 30 minutes to get to the 1st supply center from any points of the service area of the 1st point.
    
    isFromCenter - whether to analyze from the supply center point. The parameter is optional. The default is false, which means the analysis doesn't start from the center point.
    Whether to analyze from the center point shows the relation mode between the supply center and the demand points. If the analysis starts from the supply center, it means the supply center actively delivers services to demand points. If the analysis doesn't start from the supply center, the demand point actively gets the services from the supply center and the supply center passively provides the services
    
    For instance, when analyzing the service area of a milk station, isFromCenter needs to be set to true because the milk station actively sends milk to residents. However, when analyzing the service area of a school, isFromCetner needs to be set to false because students actively come to the school to have classes every day.
    
    isCenterMutuallyExclusive - Whether the service areas are mutually exclusive. This parameter is optional. The default is false, which means service areas are not mutually exclusive. If set to true, overlapping service areas will be handled. Note: Supply center mutual exclusion is not supported currently.
    Below shows the effects before and after exclusion handling.
    
    A result without no-overlay processing A result after overlay processing
    
    Returns:
    
    The service area analysis result. It is an array whose size is the same with the number of the supply center. Every element in the array corresponds to the description of a service area of a supply center.
  - findTSPPath
```
TSPPaths findTSPPath(int[] nodeIDsToVisit,
                   boolean endNodeAssigned,
                   TransportationAnalystParameter parameter)
```
    The traveling salesmen analysis.
    
    The traveling salesmen analysis is to find out the path that passes a specified set of points, with the least (or almost least) impedance. The order of passing those points are not fixed and is decided through the analysis.
    
    In traveling salesmen analysis, if the end node is specified, the traveling salesmen must access the end node last. The access order of other nodes is determined by the traveling salesmen.
    
    The passing points needed to be visited are specified by using nodeI|DsToVisit parameter, of which the first node is the starting point for the traveling salesman.
    
    Similarities and differences between optimal path analysis and traveling salesmen analysis:
    - Similarities: Both of them aim at finding out the least cost path by traversing network nodes.
    - The difference: They handle the order in which the points are visited differently. In an optimal path analysis, the points have to be visited in a specified order. Whereas in a traveling salesmen analysis, the best order for visiting the points is to be determined and is not necessarily the same with any specified order. For detailed information on optimal path analysis, please see the #findPath(Point2D[],boolean,String,TransportationAnalystParameter).
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    nodeIDsToVisit - The IDs of the nodes to pass through. This parameter is required.
    
    endNodeAssigned - Whether to assign the end node, which is an optional parameter. The default is false. If it is true, it represents assigning the end node. The traveling salesmen must access the end node, i.e., the last passing point.
    
    Returns:
    
    The traveling salesmen analysis result collection, which only includes one element now.
  - findTSPPath
```
TSPPaths findTSPPath(Point2D[] pointsToVisit,
                   boolean endNodeAssigned,
                   TransportationAnalystParameter parameter)
```
    The traveling salesmen analysis.
    
    The traveling salesmen analysis is to find out the path that passes a specified set of points, with the least (or almost least) impedance. The order of passing those points are not fixed and is decided through the analysis.
    
    In traveling salesmen analysis, if the end node is specified, the traveling salesmen must access the end node last. The access order of other nodes is determined by the traveling salesmen.
    
    The passing points needed to be visited are specified by using nodeI|DsToVisit parameter, of which the first node is the starting point for the traveling salesman.
    
    Similarities and differences between optimal path analysis and traveling salesmen analysis:
    - Similarities: Both of them aim at finding out the least cost path by traversing network nodes.
    - The difference: They handle the order in which the points are visited differently. In an optimal path analysis, the points have to be visited in a specified order. Whereas in a traveling salesmen analysis, the best order for visiting the points is to be determined and is not necessarily the same with any specified order. For detailed information on optimal path analysis, please see the #findPath(Point2D[],boolean,String,TransportationAnalystParameter).
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    parameter - The common parameter for setting transportation network analysis. It's optional, and uses the settings of TransportationAnalystSetting by default.
    
    pointsToVisit - The coordinates of the nodes to pass through. This parameter is required.
    
    endNodeAssigned - Whether to assign the end node, which is an optional parameter. The default is false. If it is true, it represents assigning the end node. The traveling salesmen must access the end node, i.e., the last passing point.
    
    Returns:
    
    The traveling salesmen analysis result collection, which only includes one element now.
  - updateEdgeWeight
```
double updateEdgeWeight(int edgeID,
                      int fromNodeID,
                      int toNodeID,
                      java.lang.String weightField,
                      double weight)
```
    Updates the edge weight.
    
    Parameters:
    
    networkDataName - Required, used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    edgeID - The target edge ID.
    
    fromNodeID - The start node ID of the target edge.
    
    toNodeID - The end node ID of the target edge.
    
    weightField - The name of the weight information (WeightFieldInfo corresponding to the target edge. Parameters fromNodeID and toNodeID determine which field to update, the from-to or the to-from field.
    
    weight - The new weight.
    
    Returns:
    
    The original weight if the update is successful, or the minimum value of the double data type otherwise.
  - updateTurnNodeWeight
```
double updateTurnNodeWeight(int nodeID,
                          int fromEdgeID,
                          int toEdgeID,
                          java.lang.String turnWeightField,
                          double weight)
```
    Updates the weight of turn node.
    
    Parameters:
    
    networkDataName - Used to uniquely identify the network dataset. It is one of elements of the array returned by #getNetworkDataNames().
    
    nodeID - The target turn node ID.
    
    fromEdgeID - The start edge ID of the target turn node.
    
    toEdgeID - The end edge ID of the target turn node.
    
    turnWeightField - The name of the turn weight filed.
    
    weight - The new weight.
    
    Returns:
    
    The original weight if the update is successful, or the minimum value of the double data type otherwise.
  - getNetworkDataName
```
java.lang.String getNetworkDataName()
```
    Gets the network data name.
    
    Returns:
    
    The network data name.
  - getPrjCoordSys
```
PrjCoordSys getPrjCoordSys()
```
    Gets the projection information of the network data.
    
    Returns:
  - getWeightNames
```
java.lang.String[] getWeightNames()
```
    Gets the name of the weight field in a network dataset.
    
    Returns:
  - getTurnWeightNames
```
java.lang.String[] getTurnWeightNames()
```
    Gets the name of the turn weight field in a network dataset.
    
    Returns:
  - reloadModel
```
boolean reloadModel()
```
    Reloads the network model.
    
    Returns:
  - findCriticalFacilitiesUpFromEdge
```
FacilityAnalyst2DResult findCriticalFacilitiesUpFromEdge(int[] sourceNodeIDs,
                                                       int edgeID,
                                                       FacilityAnalystParameter parameter)
```
  - findCriticalFacilitiesDownFromEdge
```
FacilityAnalyst2DResult findCriticalFacilitiesDownFromEdge(int[] sourceNodeIDs,
                                                         int edgeID,
                                                         FacilityAnalystParameter parameter)
```
  - findCriticalFacilitiesUpFromNode
```
FacilityAnalyst2DResult findCriticalFacilitiesUpFromNode(int[] sourceNodeIDs,
                                                       int nodeID,
                                                       FacilityAnalystParameter parameter)
```
  - findCriticalFacilitiesDownFromNode
```
FacilityAnalyst2DResult findCriticalFacilitiesDownFromNode(int[] sourceNodeIDs,
                                                         int nodeID,
                                                         FacilityAnalystParameter parameter)
```
  - burstAnalyseFromNode
```
BurstAnalyseResult burstAnalyseFromNode(int[] sourceNodeIDs,
                                      int nodeID,
                                      FacilityAnalystParameter parameter)
```
  - burstAnalyseFromEdge
```
BurstAnalyseResult burstAnalyseFromEdge(int[] sourceNodeIDs,
                                      int edgeID,
                                      FacilityAnalystParameter parameter)
```
  - findConnectedEdgesFromEdges
```
FacilityAnalyst2DResult findConnectedEdgesFromEdges(int[] edgeIDs,
                                                  boolean returnFeatures,
                                                  boolean connected)
```
    Finds the connected edges for the edges specified with ID array. The ID array of the connected edges and features array will be returned.
    
    Parameters:
    
    edgeIDs - The ID array of the specified edges.
    
    connected - Connected or unconnected. If set to true, it will return the connected edges; false, return the unconnected edges.
    
    returnFeatures - Whether to return features. If set to true, it will return features; false, doesn't return.
    
    Returns:
  - findConnectedEdgesFromNodes
```
FacilityAnalyst2DResult findConnectedEdgesFromNodes(int[] nodeIDs,
                                                  boolean returnFeatures,
                                                  boolean connected)
```
    Finds the connected or unconnected edges for the nodes specified with ID array. And the ID array of the edges and features array will be returned.
    
    Parameters:
    
    nodeIDs - The iD array of the specified nodes.
    
    connected - Connected or unconnected. If set to true, it will return the connected edges; false, return the unconnected edges.
    
    returnFeatures - Whether to return features. If set to true, it will return features; false, doesn't return.
    
    Returns:
  - traceDownFromNode
```
FacilityAnalyst2DResult traceDownFromNode(int nodeID,
                                        FacilityAnalystParameter parameter)
```
    Traces down with the specified node ID, ie., finding the downstream of the specified node, and returning the edges and nodes the downstream includes and the total cost
    
    Parameters:
    
    nodeID -
    
    parameter -
    
    Returns:
  - traceUpFromNode
```
FacilityAnalyst2DResult traceUpFromNode(int nodeID,
                                      FacilityAnalystParameter parameter)
```
    Traces up with the specified node ID, ie., finding the upstream of the specified node, and returning the edges and nodes the upstream includes and the total cost
    
    Parameters:
    
    nodeID - The specified node ID
    
    parameter -
    
    Returns:
  - traceDownFromEdge
```
FacilityAnalyst2DResult traceDownFromEdge(int edgeID,
                                        FacilityAnalystParameter parameter)
```
    Traces down with the specified edge ID, ie., finding the downstream of the specified edge, and returning the edges and nodes the downstream includes and the total cost
    
    Parameters:
    
    edgeID - The specified edge ID
    
    parameter -
    
    Returns:
  - traceUpFromEdge
```
FacilityAnalyst2DResult traceUpFromEdge(int edgeID,
                                      FacilityAnalystParameter parameter)
```
    Traces up with the specified edge ID, ie., finding the upstream of the specified edge, and returning the edges and nodes the upstream includes and the total cost
    
    Parameters:
    
    edgeID - The specified edge ID
    
    parameter -
    
    Returns:


A result without no-overlay processing	A result after overlay processing

Interface TransportationAnalystProvider

Method Summary

Method Detail

computeWeightMatrix

computeWeightMatrix

findClosestFacility

findClosestFacility

findLocation

findMTSPPath

findMTSPPath

findPath

findPath

findServiceArea

findServiceArea

findTSPPath

findTSPPath

updateEdgeWeight

updateTurnNodeWeight

getNetworkDataName

getPrjCoordSys

getWeightNames

getTurnWeightNames

reloadModel

findCriticalFacilitiesUpFromEdge

findCriticalFacilitiesDownFromEdge

findCriticalFacilitiesUpFromNode

findCriticalFacilitiesDownFromNode

burstAnalyseFromNode

burstAnalyseFromEdge

findConnectedEdgesFromEdges

findConnectedEdgesFromNodes

traceDownFromNode

traceUpFromNode

traceDownFromEdge

traceUpFromEdge