Add Average Speed as PathDetails to Response

core/src/main/java/com/graphhopper/GHRequest.java

@@ -39,6 +39,7 @@ public class GHRequest {
     // Headings are north based azimuth (clockwise) in (0, 360) or NaN for equal preference
     private final List<Double> favoredHeadings;
     private List<String> pointHints = new ArrayList<>();
+    private List<String> pathDetails = new ArrayList<>();
     private String algo = "";
     private boolean possibleToAdd = false;
     private Locale locale = Locale.US;
@@ -253,6 +254,15 @@ public boolean hasPointHints() {
         return pointHints.size() == points.size();
     }
 
+    public GHRequest setPathDetails(List<String> pathDetails) {
+        this.pathDetails = pathDetails;
+        return this;
+    }
+
+    public List<String> getPathDetails() {
+        return this.pathDetails;
+    }
+
     @Override
     public String toString() {
         String res = "";
@@ -266,6 +276,12 @@ public String toString() {
         if (!algo.isEmpty())
             res += " (" + algo + ")";
 
+        if (!pathDetails.isEmpty())
+            res += " (PathDetails: " + pathDetails + ")";
+
+        if (!hints.isEmpty())
+            res += " (Hints:" + hints + ")";
+
         return res;
     }
 }

core/src/main/java/com/graphhopper/GraphHopper.java

@@ -41,6 +41,7 @@
 import com.graphhopper.util.Parameters.CH;
 import com.graphhopper.util.Parameters.Landmark;
 import com.graphhopper.util.Parameters.Routing;
+import com.graphhopper.util.details.PathDetailsBuilderFactory;
 import com.graphhopper.util.exceptions.PointDistanceExceededException;
 import com.graphhopper.util.exceptions.PointOutOfBoundsException;
 import com.graphhopper.util.shapes.BBox;
@@ -1050,11 +1051,14 @@ else if (ALT_ROUTE.equalsIgnoreCase(algoStr))
                 boolean tmpEnableInstructions = hints.getBool(Routing.INSTRUCTIONS, enableInstructions);
                 boolean tmpCalcPoints = hints.getBool(Routing.CALC_POINTS, calcPoints);
                 double wayPointMaxDistance = hints.getDouble(Routing.WAY_POINT_MAX_DISTANCE, 1d);
+                PathDetailsBuilderFactory calculatorFactory = new PathDetailsBuilderFactory(request.getPathDetails(), encoder);
+
                 DouglasPeucker peucker = new DouglasPeucker().setMaxDistance(wayPointMaxDistance);
                 PathMerger pathMerger = new PathMerger().
                         setCalcPoints(tmpCalcPoints).
                         setDouglasPeucker(peucker).
                         setEnableInstructions(tmpEnableInstructions).
+                        setPathDetailsBuilderFactory(calculatorFactory).
                         setSimplifyResponse(simplifyResponse && wayPointMaxDistance > 0);
 
                 if (routingTemplate.isReady(pathMerger, tr))

core/src/main/java/com/graphhopper/PathWrapper.java

@@ -18,13 +18,13 @@
 package com.graphhopper;
 
 import com.graphhopper.util.InstructionList;
+import com.graphhopper.util.PathMerger;
 import com.graphhopper.util.PointList;
+import com.graphhopper.util.details.PathDetail;
 import com.graphhopper.util.shapes.BBox;
 
 import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 
 /**
  * This class holds the data like points and instructions of a Path.
@@ -46,6 +46,7 @@ public class PathWrapper {
     private PointList pointList = PointList.EMPTY;
     private int numChanges;
     private final List<Trip.Leg> legs = new ArrayList<>();
+    private Map<String, List<PathDetail>> pathDetails = new HashMap<>();
     private BigDecimal fare;
 
     /**
@@ -242,6 +243,30 @@ public void setInstructions(InstructionList instructions) {
         this.instructions = instructions;
     }
 
+    /**
+     * Adds the given PathDetails to the existing ones. If there are already PathDetails set, the number
+     * details has to be equal to <code>details</code>.
+     *
+     * @param details The PathDetails to add
+     */
+    public void addPathDetails(Map<String, List<PathDetail>> details) {
+        if (!this.pathDetails.isEmpty() && !details.isEmpty() && this.pathDetails.size() != details.size()) {
+            throw new IllegalStateException("Details have to be the same size");
+        }
+        for (Map.Entry<String, List<PathDetail>> detailEntry : details.entrySet()) {
+            if (this.pathDetails.containsKey(detailEntry.getKey())) {
+                List<PathDetail> pd = this.pathDetails.get(detailEntry.getKey());
+                PathMerger.merge(pd, detailEntry.getValue());
+            } else {
+                this.pathDetails.put(detailEntry.getKey(), detailEntry.getValue());
+            }
+        }
+    }
+
+    public Map<String, List<PathDetail>> getPathDetails() {
+        return this.pathDetails;
+    }
+
     private void check(String method) {
         if (hasErrors()) {
             throw new RuntimeException("You cannot call " + method + " if response contains errors. Check this with ghResponse.hasErrors(). "

core/src/main/java/com/graphhopper/routing/Path.java

@@ -20,22 +20,20 @@
 import com.carrotsearch.hppc.IntArrayList;
 import com.carrotsearch.hppc.IntIndexedContainer;
 import com.graphhopper.coll.GHIntArrayList;
-import com.graphhopper.debatty.java.stringsimilarity.JaroWinkler;
-import com.graphhopper.routing.util.DataFlagEncoder;
-import com.graphhopper.routing.util.DefaultEdgeFilter;
 import com.graphhopper.routing.util.FlagEncoder;
 import com.graphhopper.routing.weighting.Weighting;
 import com.graphhopper.storage.Graph;
 import com.graphhopper.storage.NodeAccess;
 import com.graphhopper.storage.SPTEntry;
 import com.graphhopper.util.*;
-import com.graphhopper.util.shapes.GHPoint;
+import com.graphhopper.util.details.PathDetail;
+import com.graphhopper.util.details.PathDetailsBuilder;
+import com.graphhopper.util.details.PathDetailsBuilderFactory;
+import com.graphhopper.util.details.PathDetailsFromEdges;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 
 /**
  * Stores the nodes for the found path of an algorithm. It additionally needs the edgeIds to make
@@ -372,6 +370,32 @@ public InstructionList calcInstructions(final Translation tr) {
         return ways;
     }
 
+    /**
+     * Calculates the PathDetails for this Path. This method will return fast, if there are no calculators.
+     *
+     * @param pathBuilderFactory Generates the relevant PathBuilders, accepts null inputs
+     * @return List of PathDetails for this Path
+     */
+    public Map<String, List<PathDetail>> calcDetails(final PathDetailsBuilderFactory pathBuilderFactory, int previousIndex) {
+        if (!isFound() || pathBuilderFactory == null)
+            return Collections.EMPTY_MAP;
+        List<PathDetailsBuilder> pathBuilders = pathBuilderFactory.createPathDetailsBuilders();
+        if (pathBuilders.isEmpty())
+            return Collections.EMPTY_MAP;
+
+        forEveryEdge(new PathDetailsFromEdges(pathBuilders, previousIndex));
+
+        Map<String, List<PathDetail>> pathDetails = new HashMap<>(pathBuilders.size());
+        for (PathDetailsBuilder builder : pathBuilders) {
+            Map.Entry<String, List<PathDetail>> entry = builder.build();
+            List<PathDetail> existing = pathDetails.put(entry.getKey(), entry.getValue());
+            if (existing != null)
+                throw new IllegalStateException("Some PathDetailsBuilders use duplicate key: " + entry.getKey());
+        }
+
+        return pathDetails;
+    }
+
     @Override
     public String toString() {
         return "distance:" + getDistance() + ", edges:" + edgeIds.size();
@@ -393,6 +417,7 @@ public String toDetailsString() {
      */
     public interface EdgeVisitor {
         void next(EdgeIteratorState edge, int index, int prevEdgeId);
+
         void finish();
     }
 }

core/src/main/java/com/graphhopper/util/DouglasPeucker.java

@@ -54,28 +54,44 @@ public DouglasPeucker setMaxDistance(double dist) {
     }
 
     /**
-     * This method removes points which are close to the line (defined by maxDist).
+     * Simplifies the <code>points</code>, from index 0 to size-1.
      * <p>
+     * It is a wrapper method for {@link DouglasPeucker#simplify(PointList, int, int)}.
      *
-     * @return removed nodes
+     * @return The number removed points
      */
     public int simplify(PointList points) {
+        return simplify(points, 0, points.size() - 1);
+    }
+
+    /**
+     * Simplifies a part of the <code>points</code>. The <code>fromIndex</code> and <code>lastIndex</code>
+     * are guaranteed to be kept.
+     *
+     * @param points    The PointList to simplify
+     * @param fromIndex Start index to simplify, should be >= <code>lastIndex</code>
+     * @param lastIndex Simplify up to this index
+     * @return The number of removed points
+     */
+    public int simplify(PointList points, int fromIndex, int lastIndex) {
         int removed = 0;
-        int size = points.getSize();
+        int size = lastIndex - fromIndex;
         if (approx) {
             int delta = 500;
             int segments = size / delta + 1;
-            int start = 0;
+            int start = fromIndex;
             for (int i = 0; i < segments; i++) {
                 // start of next is end of last segment, except for the last
-                removed += simplify(points, start, Math.min(size - 1, start + delta));
+                removed += subSimplify(points, start, Math.min(lastIndex, start + delta));
                 start += delta;
             }
         } else {
-            removed = simplify(points, 0, size - 1);
+            removed = subSimplify(points, fromIndex, lastIndex);
         }
 
-        compressNew(points, removed);
+        if (removed > 0)
+            compressNew(points, removed);
+
         return removed;
     }
 
@@ -111,7 +127,7 @@ void compressNew(PointList points, int removed) {
     }
 
     // keep the points of fromIndex and lastIndex
-    int simplify(PointList points, int fromIndex, int lastIndex) {
+    int subSimplify(PointList points, int fromIndex, int lastIndex) {
         if (lastIndex - fromIndex < 2) {
             return 0;
         }
@@ -145,8 +161,8 @@ int simplify(PointList points, int fromIndex, int lastIndex) {
                 counter++;
             }
         } else {
-            counter = simplify(points, fromIndex, indexWithMaxDist);
-            counter += simplify(points, indexWithMaxDist, lastIndex);
+            counter = subSimplify(points, fromIndex, indexWithMaxDist);
+            counter += subSimplify(points, indexWithMaxDist, lastIndex);
         }
         return counter;
     }

core/src/main/java/com/graphhopper/util/Instruction.java

@@ -41,7 +41,7 @@ public class Instruction {
     public static final int PT_TRANSFER = 102;
     public static final int PT_END_TRIP = 103;
     private static final AngleCalc AC = Helper.ANGLE_CALC;
-    protected final PointList points;
+    protected PointList points;
     protected final InstructionAnnotation annotation;
     protected boolean rawName;
     protected int sign;
@@ -137,14 +137,20 @@ public Instruction setTime(long time) {
         return points.getElevation(0);
     }
 
+    /* This method returns the points associated to this instruction. Please note that it will not include the last point,
+     * i.e. the first point of the next instruction object.
+     */
     public PointList getPoints() {
         return points;
     }
 
+    public void setPoints(PointList points) {
+        this.points = points;
+    }
+
     /**
      * This method returns a list of gpx entries where the time (in time) is relative to the first
      * which is 0. It does NOT contain the last point which is the first of the next instruction.
-     * <p>
      *
      * @return the time offset to add for the next instruction
      */

core/src/main/java/com/graphhopper/util/Parameters.java

@@ -186,6 +186,16 @@ public static final class NON_CH {
         public static final String MAX_NON_CH_POINT_DISTANCE = ROUTING_INIT_PREFIX + NON_CH_PREFIX + "max_waypoint_distance";
     }
 
+    /**
+     * Properties for the details response
+     */
+    public static final class DETAILS {
+
+        public static final String PATH_DETAILS = "details";
+
+        public static final String AVERAGE_SPEED = "average_speed";
+    }
+
     public static final class PT {
         public static final String EARLIEST_DEPARTURE_TIME = "pt.earliest_departure_time";
         public static final String PROFILE_QUERY = "pt.profile";