First compiling version of map_match plugin

include/engine/map_matching/hidden_markov_model.hpp

@@ -52,23 +52,21 @@ template <class CandidateLists> struct HiddenMarkovModel
 {
     std::vector<std::vector<double>> viterbi;
     std::vector<std::vector<std::pair<unsigned, unsigned>>> parents;
-    std::vector<std::vector<float>> path_lengths;
+    std::vector<std::vector<float>> path_distances;
     std::vector<std::vector<bool>> pruned;
-    std::vector<std::vector<bool>> suspicious;
     std::vector<bool> breakage;
 
     const CandidateLists &candidates_list;
-    const EmissionLogProbability &emission_log_probability;
+    const std::vector<std::vector<double>> &emission_log_probabilities;
 
     HiddenMarkovModel(const CandidateLists &candidates_list,
-                      const EmissionLogProbability &emission_log_probability)
+                      const std::vector<std::vector<double>> &emission_log_probabilities)
         : breakage(candidates_list.size()), candidates_list(candidates_list),
-          emission_log_probability(emission_log_probability)
+          emission_log_probabilities(emission_log_probabilities)
     {
         viterbi.resize(candidates_list.size());
         parents.resize(candidates_list.size());
-        path_lengths.resize(candidates_list.size());
-        suspicious.resize(candidates_list.size());
+        path_distances.resize(candidates_list.size());
         pruned.resize(candidates_list.size());
         breakage.resize(candidates_list.size());
         for (const auto i : util::irange<std::size_t>(0u, candidates_list.size()))
@@ -79,8 +77,7 @@ template <class CandidateLists> struct HiddenMarkovModel
             {
                 viterbi[i].resize(num_candidates);
                 parents[i].resize(num_candidates);
-                path_lengths[i].resize(num_candidates);
-                suspicious[i].resize(num_candidates);
+                path_distances[i].resize(num_candidates);
                 pruned[i].resize(num_candidates);
             }
         }
@@ -90,15 +87,14 @@ template <class CandidateLists> struct HiddenMarkovModel
 
     void clear(std::size_t initial_timestamp)
     {
-        BOOST_ASSERT(viterbi.size() == parents.size() && parents.size() == path_lengths.size() &&
-                     path_lengths.size() == pruned.size() && pruned.size() == breakage.size());
+        BOOST_ASSERT(viterbi.size() == parents.size() && parents.size() == path_distances.size() &&
+                     path_distances.size() == pruned.size() && pruned.size() == breakage.size());
 
         for (const auto t : util::irange(initial_timestamp, viterbi.size()))
         {
             std::fill(viterbi[t].begin(), viterbi[t].end(), IMPOSSIBLE_LOG_PROB);
             std::fill(parents[t].begin(), parents[t].end(), std::make_pair(0u, 0u));
-            std::fill(path_lengths[t].begin(), path_lengths[t].end(), 0);
-            std::fill(suspicious[t].begin(), suspicious[t].end(), true);
+            std::fill(path_distances[t].begin(), path_distances[t].end(), 0);
             std::fill(pruned[t].begin(), pruned[t].end(), true);
         }
         std::fill(breakage.begin() + initial_timestamp, breakage.end(), true);
@@ -113,11 +109,9 @@ template <class CandidateLists> struct HiddenMarkovModel
 
             for (const auto s : util::irange<std::size_t>(0u, viterbi[initial_timestamp].size()))
             {
-                viterbi[initial_timestamp][s] =
-                    emission_log_probability(candidates_list[initial_timestamp][s].distance);
+                viterbi[initial_timestamp][s] = emission_log_probabilities[initial_timestamp][s];
                 parents[initial_timestamp][s] = std::make_pair(initial_timestamp, s);
                 pruned[initial_timestamp][s] = viterbi[initial_timestamp][s] < MINIMAL_LOG_PROB;
-                suspicious[initial_timestamp][s] = false;
 
                 breakage[initial_timestamp] =
                     breakage[initial_timestamp] && pruned[initial_timestamp][s];

include/engine/map_matching/matching_confidence.hpp

@@ -0,0 +1,58 @@
+#ifndef ENGINE_MAP_MATCHING_CONFIDENCE_HPP
+#define ENGINE_MAP_MATCHING_CONFIDENCE_HPP
+
+#include "engine/map_matching/bayes_classifier.hpp"
+
+#include <cmath>
+
+namespace osrm
+{
+namespace engine
+{
+namespace map_matching
+{
+
+struct MatchingConfidence
+{
+private:
+    using ClassifierT = BayesClassifier<LaplaceDistribution, LaplaceDistribution, double>;
+    using TraceClassification = ClassifierT::ClassificationT;
+
+public:
+    MatchingConfidence()
+        : // the values were derived from fitting a laplace distribution
+          // to the values of manually classified traces
+          classifier(map_matching::LaplaceDistribution(0.005986, 0.016646),
+                     map_matching::LaplaceDistribution(0.054385, 0.458432),
+                     0.696774) // valid apriori probability
+    {
+    }
+
+    double operator()(const float trace_length, const float matched_length) const
+    {
+        const double distance_feature = -std::log(trace_length) + std::log(matched_length);
+
+        // matched to the same point
+        if (!std::isfinite(distance_feature))
+        {
+            return 0;
+        }
+
+        const auto label_with_confidence = classifier.classify(distance_feature);
+        if (label_with_confidence.first == ClassifierT::ClassLabel::POSITIVE)
+        {
+            return label_with_confidence.second;
+        }
+
+        BOOST_ASSERT(label_with_confidence.first == ClassifierT::ClassLabel::NEGATIVE);
+        return 1 - label_with_confidence.second;
+    }
+private:
+
+    ClassifierT classifier;
+};
+}
+}
+}
+
+#endif

include/engine/map_matching/sub_matching.hpp

@@ -0,0 +1,26 @@
+#ifndef MAP_MATCHING_SUB_MATCHING_HPP
+#define MAP_MATCHING_SUB_MATCHING_HPP
+
+#include "engine/phantom_node.hpp"
+
+#include <vector>
+
+namespace osrm
+{
+namespace engine
+{
+namespace map_matching
+{
+
+struct SubMatching
+{
+    std::vector<PhantomNode> nodes;
+    std::vector<unsigned> indices;
+    double confidence;
+};
+
+}
+}
+}
+
+#endif