add plumbing for shortest distance(ish) routes for just auto costing

valhalla · nilsnolde · Oct 25, 2020 · Aug 24, 2020 · Aug 24, 2020 · Aug 24, 2020
commit b7064fc2b73e2d141db5f8bdb3fc572f1b0fc2ac
diff --git a/proto/options.proto b/proto/options.proto
@@ -114,6 +114,7 @@ message CostingOptions {
   optional float bike_share_penalty = 57;
   optional float rail_ferry_cost = 58;
   optional float use_rail_ferry = 59;
+  optional bool shortest = 60;
 
   // these are not specified directly by the user but they get filled in as the request is parsed and fulfilled
   optional Costing costing = 90;

diff --git a/src/sif/autocost.cc b/src/sif/autocost.cc
@@ -446,13 +446,21 @@ Cost AutoCost::EdgeCost(const baldr::DirectedEdge* edge,
                         const baldr::GraphTile* tile,
                         const uint32_t seconds) const {
   auto speed = tile->GetSpeed(edge, flow_mask_, seconds);
+  assert(speed < speedfactor_.size());
+  float sec = (edge->length() * speedfactor_[speed]);
+
+  if (shortest_) {
+    return Cost(edge->length(), sec);
+  }
+
   float factor =
       (edge->use() == Use::kFerry)
           ? ferry_factor_
           : (edge->use() == Use::kRailFerry) ? rail_ferry_factor_ : density_factor_[edge->density()];
 
   factor += highway_factor_ * kHighwayFactor[static_cast<uint32_t>(edge->classification())] +
             surface_factor_ * kSurfaceFactor[static_cast<uint32_t>(edge->surface())];
+
   if (edge->toll()) {
     factor += toll_factor_;
   }
@@ -461,8 +469,6 @@ Cost AutoCost::EdgeCost(const baldr::DirectedEdge* edge,
     factor *= alley_factor_;
   }
 
-  assert(speed < speedfactor_.size());
-  float sec = (edge->length() * speedfactor_[speed]);
   return Cost(sec * factor, sec);
 }
 
@@ -502,7 +508,7 @@ Cost AutoCost::TransitionCost(const baldr::DirectedEdge* edge,
     if (!edge->has_flow_speed() || flow_mask_ == 0)
       seconds *= trans_density_factor_[node->density()];
 
-    c.cost += seconds;
+    c.cost += shortest_ ? 0.f : seconds;
     c.secs += seconds;
   }
   return c;
@@ -546,8 +552,8 @@ Cost AutoCost::TransitionCostReverse(const uint32_t idx,
     if (!edge->has_flow_speed() || flow_mask_ == 0)
       seconds *= trans_density_factor_[node->density()];
 
+    c.cost += shortest_ ? 0 : seconds;
     c.secs += seconds;
-    c.cost += seconds;
   }
   return c;
 }
@@ -675,6 +681,7 @@ cost_ptr_t CreateAutoCost(const CostingOptions& costing_options) {
 }
 
 /**
+ * //TODO: delete this in favor of just using the "shortest" costing option
  * Derived class providing an alternate costing for driving that is intended
  * to provide a short path.
  */
@@ -709,9 +716,14 @@ class AutoShorterCost : public AutoCost {
                         const baldr::GraphTile* tile,
                         const uint32_t seconds) const {
     auto speed = tile->GetSpeed(edge, flow_mask_, seconds);
+    float sec = edge->length() * speedfactor_[speed];
+
+    if (shortest_) {
+      return Cost(edge->length(), sec);
+    }
+
     float factor = (edge->use() == Use::kFerry) ? ferry_factor_ : 1.0f;
-    return Cost(edge->length() * adjspeedfactor_[speed] * factor,
-                edge->length() * speedfactor_[speed]);
+    return Cost(edge->length() * adjspeedfactor_[speed] * factor, sec);
   }
 
   /**
@@ -1012,11 +1024,16 @@ class HOVCost : public AutoCost {
                         const baldr::GraphTile* tile,
                         const uint32_t seconds) const {
     auto speed = tile->GetSpeed(edge, flow_mask_, seconds);
+    float sec = edge->length() * speedfactor_[speed];
+
+    if (shortest_) {
+      return Cost(edge->length(), sec);
+    }
+
     float factor = (edge->use() == Use::kFerry) ? ferry_factor_ : density_factor_[edge->density()];
     if ((edge->forwardaccess() & kHOVAccess) && !(edge->forwardaccess() & kAutoAccess)) {
       factor *= kHOVFactor;
     }
-    float sec = (edge->length() * speedfactor_[speed]);
     return Cost(sec * factor, sec);
   }
 
@@ -1218,11 +1235,16 @@ class TaxiCost : public AutoCost {
                         const baldr::GraphTile* tile,
                         const uint32_t seconds) const {
     auto speed = tile->GetSpeed(edge, flow_mask_, seconds);
+    float sec = edge->length() * speedfactor_[speed];
+
+    if (shortest_) {
+      return Cost(edge->length(), sec);
+    }
+
     float factor = (edge->use() == Use::kFerry) ? ferry_factor_ : density_factor_[edge->density()];
     if ((edge->forwardaccess() & kTaxiAccess) && !(edge->forwardaccess() & kAutoAccess)) {
       factor *= kTaxiFactor;
     }
-    float sec = (edge->length() * speedfactor_[speed]);
     return Cost(sec * factor, sec);
   }
 

diff --git a/src/sif/dynamiccost.cc b/src/sif/dynamiccost.cc
@@ -50,7 +50,7 @@ namespace sif {
 
 DynamicCost::DynamicCost(const CostingOptions& options, const TravelMode mode)
     : pass_(0), allow_transit_connections_(false), allow_destination_only_(true), travel_mode_(mode),
-      flow_mask_(kDefaultFlowMask) {
+      flow_mask_(kDefaultFlowMask), shortest_(options.shotest()) {
   // Parse property tree to get hierarchy limits
   // TODO - get the number of levels
   uint32_t n_levels = sizeof(kDefaultMaxUpTransitions) / sizeof(kDefaultMaxUpTransitions[0]);
@@ -218,6 +218,8 @@ void ParseSharedCostOptions(const rapidjson::Value& value, CostingOptions* pbf_c
   if (name) {
     pbf_costing_options->set_name(*name);
   }
+  auto shortest = rapidjson::get<bool>(value, "/shortest", false);
+  pbf_costing_options.set_shortest(shortest);
 }
 
 void ParseCostingOptions(const rapidjson::Document& doc,

diff --git a/valhalla/sif/dynamiccost.h b/valhalla/sif/dynamiccost.h
@@ -701,6 +701,10 @@ class DynamicCost {
   // A mask which determines which flow data the costing should use from the tile
   uint8_t flow_mask_;
 
+  // Whether or not to do shortest (by length) routes
+  // Note: hierarchy pruning means some costings (auto, truck, etc) won't do absolute shortest
+  bool shortest_;
+
   /**
    * Get the base transition costs (and ferry factor) from the costing options.
    * @param costing_options Protocol buffer of costing options.
@@ -785,6 +789,9 @@ class DynamicCost {
                                          const uint32_t idx) const {
     // Cases with both time and penalty: country crossing, ferry, rail_ferry, gate, toll booth
     sif::Cost c;
+    if (shortest_) {
+      return c; // shortest ignores any penalties in favor of path length
+    }
     if (node->type() == baldr::NodeType::kBorderControl) {
       c += country_crossing_cost_;
     }