public static void assertPList(PointList expected, PointList list) {
assertEquals("size of point lists is not equal", expected.getSize(), list.getSize());
for (int i = 0; i < expected.getSize(); i++) {
assertEquals(expected.getLatitude(i), list.getLatitude(i), 1e-4);
assertEquals(expected.getLongitude(i), list.getLongitude(i), 1e-4);
}
}
public void add(PointList points) {
int newSize = size + points.getSize();
incCap(newSize);
for (int i = 0; i < points.getSize(); i++) {
int tmp = size + i;
latitudes[tmp] = points.getLatitude(i);
longitudes[tmp] = points.getLongitude(i);
if (is3D) elevations[tmp] = points.getElevation(i);
}
size = newSize;
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
PointList other = (PointList) obj;
if (other.isEmpty() && other.isEmpty()) return true;
if (this.getSize() != other.getSize() || this.is3D() != other.is3D()) return false;
for (int i = 0; i < size; i++) {
if (!NumHelper.equalsEps(latitudes[i], other.latitudes[i])) return false;
if (!NumHelper.equalsEps(longitudes[i], other.longitudes[i])) return false;
if (is3D && !NumHelper.equalsEps(elevations[i], other.elevations[i])) return false;
}
return true;
}
public TestAlgoCollector assertDistance(
AlgoHelperEntry algoEntry, List<QueryResult> queryList, OneRun oneRun) {
List<Path> altPaths = new ArrayList<Path>();
QueryGraph queryGraph = new QueryGraph(algoEntry.getQueryGraph());
queryGraph.lookup(queryList);
AlgorithmOptions opts = algoEntry.opts;
FlagEncoder encoder = opts.getFlagEncoder();
if (encoder.supports(TurnWeighting.class))
algoEntry.setAlgorithmOptions(
AlgorithmOptions.start(opts)
.weighting(
new TurnWeighting(
opts.getWeighting(),
opts.getFlagEncoder(),
(TurnCostExtension) queryGraph.getExtension()))
.build());
for (int i = 0; i < queryList.size() - 1; i++) {
RoutingAlgorithm algo = algoEntry.createAlgo(queryGraph);
Path path =
algo.calcPath(queryList.get(i).getClosestNode(), queryList.get(i + 1).getClosestNode());
// System.out.println(path.calcInstructions().createGPX("temp", 0, "GMT"));
altPaths.add(path);
}
PathMerger pathMerger =
new PathMerger().setCalcPoints(true).setSimplifyResponse(false).setEnableInstructions(true);
AltResponse rsp = new AltResponse();
pathMerger.doWork(rsp, altPaths, trMap.getWithFallBack(Locale.US));
if (rsp.hasErrors()) {
errors.add(
algoEntry
+ " response contains errors. Expected distance: "
+ rsp.getDistance()
+ ", expected points: "
+ oneRun
+ ". "
+ queryList
+ ", errors:"
+ rsp.getErrors());
return this;
}
PointList pointList = rsp.getPoints();
double tmpDist = pointList.calcDistance(distCalc);
if (Math.abs(rsp.getDistance() - tmpDist) > 2) {
errors.add(
algoEntry
+ " path.getDistance was "
+ rsp.getDistance()
+ "\t pointList.calcDistance was "
+ tmpDist
+ "\t (expected points "
+ oneRun.getLocs()
+ ", expected distance "
+ oneRun.getDistance()
+ ") "
+ queryList);
}
if (Math.abs(rsp.getDistance() - oneRun.getDistance()) > 2) {
errors.add(
algoEntry
+ " returns path not matching the expected distance of "
+ oneRun.getDistance()
+ "\t Returned was "
+ rsp.getDistance()
+ "\t (expected points "
+ oneRun.getLocs()
+ ", was "
+ pointList.getSize()
+ ") "
+ queryList);
}
// There are real world instances where A-B-C is identical to A-C (in meter precision).
if (Math.abs(pointList.getSize() - oneRun.getLocs()) > 1) {
errors.add(
algoEntry
+ " returns path not matching the expected points of "
+ oneRun.getLocs()
+ "\t Returned was "
+ pointList.getSize()
+ "\t (expected distance "
+ oneRun.getDistance()
+ ", was "
+ rsp.getDistance()
+ ") "
+ queryList);
}
return this;
}
@Override
public GHResponse route(GHRequest request) {
request.check();
StopWatch sw = new StopWatch().start();
GHResponse rsp = new GHResponse();
if (!setSupportsVehicle(request.getVehicle())) {
rsp.addError(
new IllegalArgumentException(
"Vehicle "
+ request.getVehicle()
+ " unsupported. Supported are: "
+ getEncodingManager()));
return rsp;
}
EdgeFilter edgeFilter = new DefaultEdgeFilter(encodingManager.getEncoder(request.getVehicle()));
int from =
index
.findClosest(request.getFrom().lat, request.getFrom().lon, edgeFilter)
.getClosestNode();
int to =
index.findClosest(request.getTo().lat, request.getTo().lon, edgeFilter).getClosestNode();
String debug = "idLookup:" + sw.stop().getSeconds() + "s";
if (from < 0)
rsp.addError(new IllegalArgumentException("Cannot find point 1: " + request.getFrom()));
if (to < 0)
rsp.addError(new IllegalArgumentException("Cannot find point 2: " + request.getTo()));
if (from == to) rsp.addError(new IllegalArgumentException("Point 1 is equal to point 2"));
sw = new StopWatch().start();
RoutingAlgorithm algo = null;
if (chUsage) {
if (request.getAlgorithm().equals("dijkstrabi")) algo = prepare.createAlgo();
else if (request.getAlgorithm().equals("astarbi"))
algo = ((PrepareContractionHierarchies) prepare).createAStar();
else
rsp.addError(
new IllegalStateException(
"Only dijkstrabi and astarbi is supported for LevelGraph (using contraction hierarchies)!"));
} else {
prepare =
NoOpAlgorithmPreparation.createAlgoPrepare(
graph,
request.getAlgorithm(),
encodingManager.getEncoder(request.getVehicle()),
request.getType());
algo = prepare.createAlgo();
}
if (rsp.hasErrors()) {
return rsp;
}
debug += ", algoInit:" + sw.stop().getSeconds() + "s";
sw = new StopWatch().start();
Path path = algo.calcPath(from, to);
debug +=
", "
+ algo.getName()
+ "-routing:"
+ sw.stop().getSeconds()
+ "s"
+ ", "
+ path.getDebugInfo();
PointList points = path.calcPoints();
simplifyRequest = request.getHint("simplifyRequest", simplifyRequest);
if (simplifyRequest) {
sw = new StopWatch().start();
int orig = points.getSize();
double minPathPrecision = request.getHint("douglas.minprecision", 1d);
if (minPathPrecision > 0) {
new DouglasPeucker().setMaxDistance(minPathPrecision).simplify(points);
}
debug +=
", simplify (" + orig + "->" + points.getSize() + "):" + sw.stop().getSeconds() + "s";
}
enableInstructions = request.getHint("instructions", enableInstructions);
if (enableInstructions) {
sw = new StopWatch().start();
rsp.setInstructions(path.calcInstructions());
debug += ", instructions:" + sw.stop().getSeconds() + "s";
}
return rsp.setPoints(points)
.setDistance(path.getDistance())
.setTime(path.getTime())
.setDebugInfo(debug);
}
