if (lmRsp.hasErrors()) { if (originalRsp.hasErrors()) continue; logger.error("Error for LM but not for original response " + locStr); String infoStr = " weight:" + lmRsp.getBest().getRouteWeight() + ", original: " + originalRsp.getBest().getRouteWeight() + " distance:" + lmRsp.getBest().getDistance() + ", original: " + originalRsp.getBest().getDistance() + " time:" + round2(lmRsp.getBest().getTime() / 1000) + ", original: " + round2(originalRsp.getBest().getTime() / 1000) + " points:" + lmRsp.getBest().getPoints().size() + ", original: " + originalRsp.getBest().getPoints().size(); if (Math.abs(1 - lmRsp.getBest().getRouteWeight() / originalRsp.getBest().getRouteWeight()) > 0.000001) logger.error("Too big weight difference for LM. " + locStr + infoStr);
@Override public GHResponse route(GHRequest request) { ResponseBody rspBody = null; try { Request okRequest = createRequest(request); rspBody = getClientForRequest(request).newCall(okRequest).execute().body(); JsonNode json = objectMapper.reader().readTree(rspBody.byteStream()); GHResponse res = new GHResponse(); res.addErrors(readErrors(json)); if (res.hasErrors()) return res; JsonNode paths = json.get("paths"); boolean tmpElevation = request.getHints().getBool("elevation", elevation); boolean tmpTurnDescription = request.getHints().getBool("turn_description", true); for (JsonNode path : paths) { PathWrapper altRsp = createPathWrapper(path, tmpElevation, tmpTurnDescription); res.add(altRsp); } return res; } catch (Exception ex) { throw new RuntimeException("Problem while fetching path " + request.getPoints() + ": " + ex.getMessage(), ex); } finally { Helper.close(rspBody); } }
if (rsp.hasErrors()) { if (!warmup) failedCount.incrementAndGet(); if (rsp.getErrors().get(0).getMessage() == null) rsp.getErrors().get(0).printStackTrace(); else if (!toLowerCase(rsp.getErrors().get(0).getMessage()).contains("not found")) logger.error("errors should NOT happen in Measurement! " + req + " => " + rsp.getErrors()); PathWrapper arsp = rsp.getBest(); if (!warmup) { visitedNodesSum.addAndGet(rsp.getHints().getLong("visited_nodes.sum", 0)); long dist = (long) arsp.getDistance(); distSum.addAndGet(dist);
private static Response.ResponseBuilder gpxSuccessResponseBuilder(GHResponse ghRsp, String timeString, String trackName, boolean enableElevation, boolean withRoute, boolean withTrack, boolean withWayPoints, String version) { if (ghRsp.getAll().size() > 1) { throw new IllegalArgumentException("Alternatives are currently not yet supported for GPX"); } long time = timeString != null ? Long.parseLong(timeString) : System.currentTimeMillis(); return Response.ok(ghRsp.getBest().getInstructions().createGPX(trackName, time, enableElevation, withRoute, withTrack, withWayPoints, version), "application/gpx+xml"). header("Content-Disposition", "attachment;filename=" + "GraphHopper.gpx"); }
private void parseSolutionsAndAddToResponse(List<List<Label.Transition>> solutions, PointList waypoints) { for (List<Label.Transition> solution : solutions) { final List<Trip.Leg> legs = tripFromLabel.getTrip(translation, graphExplorer, accessEgressWeighting, solution); final PathWrapper pathWrapper = tripFromLabel.createPathWrapper(translation, waypoints, legs); pathWrapper.setImpossible(solution.stream().anyMatch(t -> t.label.impossible)); pathWrapper.setTime((solution.get(solution.size()-1).label.currentTime - solution.get(0).label.currentTime)); response.add(pathWrapper); } Comparator<PathWrapper> c = Comparator.comparingInt(p -> (p.isImpossible() ? 1 : 0)); Comparator<PathWrapper> d = Comparator.comparingDouble(PathWrapper::getTime); response.getAll().sort(c.thenComparing(d)); }
StopWatch sw = new StopWatch().start(); List<QueryResult> qResults = routingTemplate.lookup(points, encoder); ghRsp.addDebugInfo("idLookup:" + sw.stop().getSeconds() + "s"); if (ghRsp.hasErrors()) return Collections.emptyList(); queryGraph.lookup(qResults); weighting = createWeighting(hints, encoder, queryGraph); ghRsp.addDebugInfo("tmode:" + tMode.toString()); ghRsp.addError(ex); return Collections.emptyList(); } finally {
+ took + ", " + algoStr + ", " + weighting + ", " + vehicleStr; if (ghResponse.hasErrors()) { logger.error(logStr + ", errors:" + ghResponse.getErrors()); throw new MultiException(ghResponse.getErrors()); } else { logger.info(logStr + ", alternatives: " + ghResponse.getAll().size() + ", distance0: " + ghResponse.getBest().getDistance() + ", weight0: " + ghResponse.getBest().getRouteWeight() + ", time0: " + Math.round(ghResponse.getBest().getTime() / 60000f) + "min" + ", points0: " + ghResponse.getBest().getPoints().getSize() + ", debugInfo: " + ghResponse.getDebugInfo()); return writeGPX ? gpxSuccessResponseBuilder(ghResponse, timeString, trackName, enableElevation, withRoute, withTrack, withWayPoints, Constants.VERSION).
public RoutingResult getRouteBetween(NavigationPosition from, NavigationPosition to, TravelMode travelMode) { initializeHopper(); long start = currentTimeMillis(); try { GHRequest request = new GHRequest(from.getLatitude(), from.getLongitude(), to.getLatitude(), to.getLongitude()); request.setVehicle(travelMode.getName().toUpperCase()); GHResponse response = hopper.route(request); if(response.hasErrors()) { String errors = printArrayToDialogString(response.getErrors().toArray(), false); log.severe(format("Error while routing between %s and %s: %s", from, to, errors)); throw new RuntimeException(errors); } PathWrapper best = response.getBest(); return new RoutingResult(asPositions(best.getPoints()), new DistanceAndTime(best.getDistance(), best.getTime() / 1000), true); } finally { long end = currentTimeMillis(); log.info("GraphHopper: routing from " + from + " to " + to + " took " + (end - start) + " milliseconds"); } }
@Override public boolean isReady(PathMerger pathMerger, Translation tr) { if (ghRequest.getPoints().size() - 1 != pathList.size()) throw new RuntimeException("There should be exactly one more points than paths. points:" + ghRequest.getPoints().size() + ", paths:" + pathList.size()); altResponse.setWaypoints(getWaypoints()); ghResponse.add(altResponse); pathMerger.doWork(altResponse, pathList, tr); return true; }
GHResponse rsp = new GHResponse(); rsp.add(pathWrapper); time = measurements.get(0).getTime(); return Response.ok(rsp.getBest().getInstructions().createGPX(gpx.trk.get(0).name != null ? gpx.trk.get(0).name : "", time, enableElevation, withRoute, withTrack, false, Constants.VERSION), "application/gpx+xml"). header("X-GH-Took", "" + Math.round(took * 1000)). build();
@Override public GHResponse route(GHRequest request) { GHResponse response = new GHResponse(); calcPaths(request, response); return response; }
public class GraphHopperWithPaths extends GraphHopper { public List<Integer> routePaths(double startY, double startX, double endY, double endX){ //Examine a route and return edgeIDs that GraphHopper uses LocationIndex index = this.getLocationIndex(); GHRequest request = new GHRequest(startY, startX, endY, endX); GHResponse response = new GHResponse(); List<Path> paths = getPaths(request, response); List<Integer> edges = new ArrayList<Integer>(); for(Path p:paths){ for(EdgeIteratorState e:p.calcEdges()){ edges.add(e.getEdge()); } } if (response.hasErrors()) return null; //Get edges for start and end point as well QueryResult qr = index.findClosest(startY, startX, EdgeFilter.ALL_EDGES ); edges.add(qr.getClosestEdge().getEdge()); qr = index.findClosest(endY, endX, EdgeFilter.ALL_EDGES ); edges.add(qr.getClosestEdge().getEdge()); return edges; } }
GHRequest req = new GHRequest(32.070113, 34.790266, 32.067103, 34.777861) .setWeighting("fastest") .setVehicle("car"); GHResponse res = gh.route(req); if(res.hasErrors()) { // handle or throw exceptions res.getErrors() return; } // get path geometry information (latitude, longitude and optionally elevation) PointList pl = res.getPoints(); // distance of the full path, in meter double distance = res.getDistance(); // time of the full path, in milliseconds long millis = res.getTime(); // get information per turn instruction InstructionList il = res.getInstructions();
@Override public List<Path> calcPaths(QueryGraph queryGraph, RoutingAlgorithmFactory algoFactory, AlgorithmOptions algoOpts) { pathList = new ArrayList<>(queryResults.size() - 1); AvoidEdgesWeighting avoidPathWeighting = new AvoidEdgesWeighting(algoOpts.getWeighting()); avoidPathWeighting.setEdgePenaltyFactor(5); algoOpts = AlgorithmOptions.start(algoOpts). algorithm(Parameters.Algorithms.ASTAR_BI). weighting(avoidPathWeighting).build(); algoOpts.getHints().put(Algorithms.AStarBi.EPSILON, 2); long visitedNodesSum = 0L; QueryResult start = queryResults.get(0); for (int qrIndex = 1; qrIndex < queryResults.size(); qrIndex++) { RoutingAlgorithm algo = algoFactory.createAlgo(queryGraph, algoOpts); // instead getClosestNode (which might be a virtual one and introducing unnecessary tails of the route) // use next tower node -> getBaseNode or getAdjNode // Later: remove potential route tail QueryResult startQR = queryResults.get(qrIndex - 1); int startNode = (startQR == start) ? startQR.getClosestNode() : startQR.getClosestEdge().getBaseNode(); QueryResult endQR = queryResults.get(qrIndex); int endNode = (endQR == start) ? endQR.getClosestNode() : endQR.getClosestEdge().getBaseNode(); Path path = algo.calcPath(startNode, endNode); visitedNodesSum += algo.getVisitedNodes(); pathList.add(path); // it is important to avoid previously visited nodes for future paths avoidPathWeighting.addEdges(path.calcEdges()); } ghResponse.getHints().put("visited_nodes.sum", visitedNodesSum); ghResponse.getHints().put("visited_nodes.average", (float) visitedNodesSum / (queryResults.size() - 1)); return pathList; }
response.addDebugInfo("routing:" + stopWatch.stop().getSeconds() + "s"); if (discoveredSolutions.isEmpty() && router.getVisitedNodes() >= maxVisitedNodesForRequest) { throw new IllegalArgumentException("No path found - maximum number of nodes exceeded: " + maxVisitedNodesForRequest); response.getHints().put("visited_nodes.sum", visitedNodes); response.getHints().put("visited_nodes.average", visitedNodes); if (discoveredSolutions.isEmpty()) { response.addError(new RuntimeException("No route found"));
public static ObjectNode jsonObject(GHResponse ghRsp, boolean enableInstructions, boolean calcPoints, boolean enableElevation, boolean pointsEncoded, float took) { ObjectNode json = JsonNodeFactory.instance.objectNode(); json.putPOJO("hints", ghRsp.getHints().toMap()); info.put("took", Math.round(took * 1000)); ArrayNode jsonPathList = json.putArray("paths"); for (PathWrapper ar : ghRsp.getAll()) { ObjectNode jsonPath = jsonPathList.addObject(); jsonPath.put("distance", Helper.round(ar.getDistance(), 3));
@Override public List<QueryResult> lookup(List<GHPoint> points, FlagEncoder encoder) { if (points.size() < 2) throw new IllegalArgumentException("At least 2 points have to be specified, but was:" + points.size()); EdgeFilter edgeFilter = DefaultEdgeFilter.allEdges(encoder); queryResults = new ArrayList<>(points.size()); for (int placeIndex = 0; placeIndex < points.size(); placeIndex++) { GHPoint point = points.get(placeIndex); QueryResult qr = null; if (ghRequest.hasPointHints()) qr = locationIndex.findClosest(point.lat, point.lon, new NameSimilarityEdgeFilter(edgeFilter, ghRequest.getPointHints().get(placeIndex))); if (qr == null || !qr.isValid()) qr = locationIndex.findClosest(point.lat, point.lon, edgeFilter); if (!qr.isValid()) ghResponse.addError(new PointNotFoundException("Cannot find point " + placeIndex + ": " + point, placeIndex)); queryResults.add(qr); } return queryResults; }
public GHResponse getResponse(GHPoint from, GHPoint to) { // The flag encoder's toString method returns the vehicle type GHRequest req = new GHRequest(from, to).setVehicle(flagEncoder.toString()); GHResponse rsp = hopper.route(req); if (rsp.hasErrors()) { return null; } return rsp; }
protected PathWrapper doInBackground(Void... v) { StopWatch sw = new StopWatch().start(); GHRequest req = new GHRequest(fromLat, fromLon, toLat, toLon). setAlgorithm(Algorithms.DIJKSTRA_BI); req.getHints(). put(Routing.INSTRUCTIONS, "false"); GHResponse resp = hopper.route(req); time = sw.stop().getSeconds(); return resp.getBest(); }