Merge pull request #39 from valhalla/dwn

Use meters for distance.

Author: dnesbitt61

src/thor/astarheuristic.cc

@@ -2,34 +2,34 @@
 
 using namespace valhalla::midgard;
 
-namespace valhalla{
-namespace thor{
-
-  // Default constructor
-  AStarHeuristic::AStarHeuristic()
-    : costfactor_(1.0f) {
-  }
-
-  // Initializes the AStar heuristic
-  void AStarHeuristic::Init(const PointLL& ll, const float factor) {
-    distapprox_.SetTestPoint(ll);
-    costfactor_ = factor;
-  }
-
-  // Ge tthe distance to the destination
-  float AStarHeuristic::GetDistance(const midgard::PointLL& ll) {
-    return sqrtf(distapprox_.DistanceSquared(ll));
-  }
-
-  // Get the A* heuristic given the lat,lng.
-  float AStarHeuristic::Get(const midgard::PointLL& ll) {
-    return sqrtf(distapprox_.DistanceSquared(ll)) * costfactor_;
-  }
-
-  // Get the A* heuristic given the distance to the destination.
-  float AStarHeuristic::Get(const float dist) {
-    return dist * costfactor_;
-  }
+namespace valhalla {
+namespace thor {
+
+// Default constructor
+AStarHeuristic::AStarHeuristic()
+  : costfactor_(1.0f) {
+}
+
+// Initializes the AStar heuristic
+void AStarHeuristic::Init(const PointLL& ll, const float factor) {
+  distapprox_.SetTestPoint(ll);
+  costfactor_ = factor;
+}
+
+// Ge tthe distance to the destination
+float AStarHeuristic::GetDistance(const midgard::PointLL& ll) {
+  return sqrtf(distapprox_.DistanceSquared(ll));
+}
+
+// Get the A* heuristic given the lat,lng.
+float AStarHeuristic::Get(const midgard::PointLL& ll) {
+  return sqrtf(distapprox_.DistanceSquared(ll)) * costfactor_;
+}
+
+// Get the A* heuristic given the distance to the destination.
+float AStarHeuristic::Get(const float dist) {
+  return dist * costfactor_;
+}
 
 }
 }

src/thor/autocost.cc

@@ -85,7 +85,7 @@ AutoCost::AutoCost()
   // Create speed cost table
   speedfactor_[0] = kSecPerHour;  // TODO - what to make speed=0?
   for (uint32_t s = 1; s < 255; s++) {
-    speedfactor_[s] = kSecPerHour / static_cast<float>(s);
+    speedfactor_[s] = (kSecPerHour * 0.001f) / static_cast<float>(s);
   }
 }
 
@@ -100,25 +100,25 @@ bool AutoCost::Allowed(const baldr::DirectedEdge* edge,  const bool uturn,
   // Allow upward transitions except when close to the destination
   if (edge->trans_up()) {
     return (edge->endnode().level() == 0) ?
-          dist2dest > 50.0f : dist2dest > 10.0f;
+          dist2dest > 50000.0f : dist2dest > 10000.0f;
   }
 
   // Allow downward transitions only when near the destination
   if (edge->trans_down()) {
     return (edge->endnode().level() == 1) ?
-          dist2dest < 50.0f : dist2dest < 10.0f;
+          dist2dest < 50000.0f : dist2dest < 10000.0f;
   }
 
   // Skip shortcut edges when near the destination
-  if (edge->shortcut() && dist2dest < 10.0f)
+  if (edge->shortcut() && dist2dest < 10000.0f)
     return false;
 
   // Do not allow Uturns or entering no-thru edges.
   // TODO - evaluate later!
   // TODO - until the opp_index is set in the new hierarchies do not test
   // for uturn!
-//  if (uturn || (edge->not_thru() && dist2dest > 5.0))
-  if ((edge->not_thru() && dist2dest > 5.0)) {
+//  if (uturn || (edge->not_thru() && dist2dest > 5000.0))
+  if ((edge->not_thru() && dist2dest > 5000.0)) {
     return false;
   }
   return (edge->forwardaccess() & kAutoAccess);

src/thor/pathalgorithm.cc

@@ -127,12 +127,12 @@ std::vector<GraphId> PathAlgorithm::GetBestPath(const PathLocation& origin,
     }
 
     // Stop expanding the local level once 50 transitions have been made
-    if (dist2dest > 10.0f && node.level() == 2 && upto1count > 50) {
+    if (dist2dest > 10000.0f && node.level() == 2 && upto1count > 50) {
       continue;
     }
 
     // Stop expanding arterial level once 250 transitions have been made
-    if (dist2dest > 50.0f && node.level() == 1 && upto0count > 250) {
+    if (dist2dest > 50000.0f && node.level() == 1 && upto0count > 250) {
       continue;
     }
 

src/thor/pedestriancost.cc

@@ -72,19 +72,17 @@ class PedestrianCost : public DynamicCost {
  private:
   // Walking speed (default to 5.1 km / hour)
   float walkingspeed_;
-  // Favor walkways and paths? (default to 0.95f)
+
+  // Favor walkways and paths? (default to 0.9f)
   float favorwalkways_;
 };
 
 // Constructor
 PedestrianCost::PedestrianCost()
     : DynamicCost(),
       walkingspeed_(5.1f),
-      favorwalkways_(0.90f) {
-
+      favorwalkways_(0.9f) {
   //TODO: load up stuff from ptree config
-  //We want to use walkways
-  favorwalkways_ = .5f;
 }
 
 // Destructor
@@ -122,7 +120,8 @@ float PedestrianCost::Get(const DirectedEdge* edge) const {
 
 // Returns the time (in seconds) to traverse the edge.
 float PedestrianCost::Seconds(const baldr::DirectedEdge* edge) const {
-  return edge->length() / walkingspeed_;
+  // meters * 3600 sec/hr / 1000 m/km)
+  return (edge->length() * 3.6f) / walkingspeed_;
 }
 
 /**
@@ -134,16 +133,13 @@ float PedestrianCost::Seconds(const baldr::DirectedEdge* edge) const {
  * estimate is less than the least possible time along roads.
  */
 float PedestrianCost::AStarCostFactor() const {
-  // Multiplied by the factor used to favor walkways/paths if < 1.0f
-  if (favorwalkways_ < 1.0f)
-    return 1.0f * favorwalkways_;
-
-  return 1.0f;
+  // Use the factor to favor walkways/paths if < 1.0f
+  return (favorwalkways_ < 1.0f) ? favorwalkways_ : 1.0f;
 }
 
 float PedestrianCost::UnitSize() const {
-  // Consider anything within 5 m to be same cost
-  return 0.005f;
+  // Consider anything within 2 m to be same cost
+  return 2.0f;
 }
 
 cost_ptr_t CreatePedestrianCost(/*pt::ptree const& config*/){

src/thor/trippathbuilder.cc

@@ -9,8 +9,8 @@
 namespace valhalla {
 namespace thor {
 
-// Kilometers offset from start/end of shape for finding heading
-constexpr float kKmOffsetForHeading = 0.03f;
+// Meters offset from start/end of shape for finding heading
+constexpr float kMetersOffsetForHeading =30.0f;
 
 // Default constructor
 TripPathBuilder::TripPathBuilder() {
@@ -79,10 +79,10 @@ TripPath TripPathBuilder::Build(GraphReader& graphreader,
 
       trip_edge->set_begin_heading(
           std::round(
-              PointLL::HeadingAlongPolyline(edgeinfo->shape(), kKmOffsetForHeading)));
+              PointLL::HeadingAlongPolyline(edgeinfo->shape(), kMetersOffsetForHeading)));
       trip_edge->set_end_heading(
           std::round(
-              PointLL::HeadingAtEndOfPolyline(edgeinfo->shape(), kKmOffsetForHeading)));
+              PointLL::HeadingAtEndOfPolyline(edgeinfo->shape(), kMetersOffsetForHeading)));
 
     } else {
 
@@ -95,13 +95,13 @@ TripPath TripPathBuilder::Build(GraphReader& graphreader,
           std::round(
               fmod(
                   (PointLL::HeadingAtEndOfPolyline(edgeinfo->shape(),
-                                                   kKmOffsetForHeading) + 180.0f), 360)));
+                               kMetersOffsetForHeading) + 180.0f), 360)));
 
       trip_edge->set_end_heading(
           std::round(
               fmod(
                   (PointLL::HeadingAlongPolyline(edgeinfo->shape(),
-                                                 kKmOffsetForHeading) + 180.0f), 360)));
+                               kMetersOffsetForHeading) + 180.0f), 360)));
     }
     trip_edge->set_end_shape_index(trip_shape.size());
 
@@ -179,7 +179,7 @@ TripPath_Edge* TripPathBuilder::AddTripEdge(const DirectedEdge* directededge,
   }
 
   // Set speed and length
-  trip_edge->set_length(directededge->length());
+  trip_edge->set_length(directededge->length() * 0.001f);  // Convert to km
   trip_edge->set_speed(directededge->speed());
 
   // Test whether edge is traversed forward or reverse and set driveability

valhalla/thor/astarheuristic.h

@@ -46,7 +46,7 @@ class AStarHeuristic {
 
   /**
    * Get the A* heuristic given the dstance to the destination.
-   * @param  distance  Distance (km) to the destination.
+   * @param  distance  Distance (meters) to the destination.
    * @return  Returns an estimate of the cost to the destination.
    *          For A* shortest path this MUST UNDERESTIMATE the true cost.
    */

valhalla/thor/edgelabel.h

@@ -29,7 +29,7 @@ class EdgeLabel {
    * @param endnode   End node of the directed edge.
    * @param cost      True cost to the edge.
    * @param sortcost  Cost for sorting (includes A* heuristic)
-   * @param dist      Distance (km) to the destination
+   * @param dist      Distance meters to the destination
    */
   EdgeLabel(const uint32_t predecessor, const baldr::GraphId& edgeid,
             const baldr::DirectedEdge* edge, const float cost,
@@ -92,7 +92,7 @@ class EdgeLabel {
 
   /**
    * Get the distance to the destination.
-   * @return  Returns the distance in km.
+   * @return  Returns the distance in meters.
    */
   float distance() const;