changes

src/osmfixer/FixerMain.cpp

@@ -69,8 +69,11 @@ int main(int argc, char** argv) {
         idx[i].first.suggIdStart + idx[i].second.maxSuggId() + 1;
   }
 
+  LOG(INFO) << "Building search index...";
+  osmfixer::SearchIdx searchIdx(idx.front().second);
+
   LOG(INFO) << "Starting server...";
-  StatServer serv(idx);
+  StatServer serv(idx, searchIdx);
 
   LOG(INFO) << "Listening on port " << port;
   util::http::HttpServer(port, &serv).run();

src/osmfixer/index/SearchIdx.cpp

@@ -0,0 +1,283 @@
+// Copyright 2019, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>.
+
+#include <algorithm>
+#include <codecvt>
+#include <fstream>
+#include <locale>
+#include <queue>
+#include <string>
+#include <vector>
+#include "util/log/Log.h"
+
+#include "osmfixer/index/SearchIdx.h"
+
+using osmfixer::SearchIdx;
+using osmfixer::TupleList;
+using osmfixer::TripleList;
+
+// _____________________________________________________________________________
+void SearchIdx::build() {
+  _qGramIndex.clear();
+
+  size_t nameid = 0;
+
+  std::map<std::wstring, size_t> tokenIds;
+
+  for (size_t gid = 0; gid < _stats.getGroups().size(); gid++) {
+		auto group = _stats.getGroup(gid);
+
+		// dont index empty groups
+		if (group->stations.size() == 0) continue;
+		if (group->polyStations.size() == 0) continue;
+
+    for (const auto& name : _stats.getGroup(gid)->uniqueNames) {
+      // use wstring to get UTF-8 chars right
+      std::wstring wname =
+          std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(name);
+
+      _nameToGroup[nameid] = gid;
+			_names.push_back(name);
+
+      for (const auto& token : tokenize(wname)) {
+        if (tokenIds.count(token)) {
+          if (_inv[tokenIds.find(token)->second].size() == 0 ||
+              _inv[tokenIds.find(token)->second].back().first != nameid) {
+            // only use a token once per station
+            _inv[tokenIds.find(token)->second].push_back({nameid, 1});
+          }
+        } else {
+          tokenIds[token] = _tokens.size();
+          _tokens.push_back(token);
+          _inv.push_back(TupleList());
+          _inv.back().push_back({nameid, 1});
+        }
+
+        size_t tokenId = tokenIds.find(token)->second;
+        for (const auto& qGram : getQGrams(token)) {
+          if (_qGramIndex[qGram].size() &&
+              _qGramIndex[qGram].back().first == tokenId) {
+            _qGramIndex[qGram].back().second++;
+          } else {
+            _qGramIndex[qGram].push_back({tokenId, 1});
+          }
+        }
+      }
+      nameid++;
+    }
+  }
+
+  for (auto& idx : _qGramIndex) std::sort(idx.second.begin(), idx.second.end());
+
+  for (auto& idx : _qGramIndex) {
+    TupleList tl;
+    for (auto& cur : idx.second) {
+      if (tl.size() != 0 && tl.back().first == cur.first)
+        tl.back().second += cur.second;
+      else
+        tl.push_back(cur);
+    }
+    idx.second = tl;
+  }
+}
+
+// _____________________________________________________________________________
+std::vector<std::wstring> SearchIdx::getQGrams(const std::wstring& word) {
+  std::vector<std::wstring> ret;
+
+  std::wstring s;
+  for (size_t i = 0; i < 2; ++i) s += '$';
+
+  s += normalize(word);
+
+  for (size_t i = 0; i < s.size() - 2; ++i) ret.push_back(s.substr(i, 3));
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+std::vector<std::wstring> SearchIdx::tokenize(const std::wstring& str) {
+  std::vector<std::wstring> ret;
+  std::wstring cur;
+
+  const wchar_t* seps = L"_-?'\"|!@#$%^&*()_+}|><.,\\";
+
+  for (size_t i = 0; i < str.size(); i++) {
+    if (std::iswspace(str[i]) || wcschr(seps, str[i])) {
+      if (cur.size()) {
+        ret.push_back(cur);
+        cur.clear();
+      }
+    } else {
+      cur += std::towlower(str[i]);
+    }
+  }
+
+  if (cur.size()) ret.push_back(cur);
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+std::wstring SearchIdx::normalize(const std::wstring& str) {
+  std::wstring s;
+  const wchar_t* unallowed = L"_-?'\"|!@#$%^&*()_+}|><.,\\";
+  for (size_t i = 0; i < str.size(); ++i) {
+    if (std::iswspace(str[i]) || wcschr(unallowed, str[i])) {
+      continue;
+    }
+    s += std::towlower(str[i]);
+  }
+
+  return s;
+}
+
+// _____________________________________________________________________________
+TripleList SearchIdx::find(const std::string& qry) const {
+  TupleList ret;
+  std::wstring wqry =
+      std::wstring_convert<std::codecvt_utf8<wchar_t>>().from_bytes(qry);
+
+  const auto& tokens = tokenize(wqry);
+
+  std::vector<TupleList> lists;
+
+  for (const auto& token : tokens) {
+    double delta = token.size() / 4.0;
+    auto res = tokenFind(token);
+
+    std::partial_sort(res.begin(), res.begin() + std::min<size_t>(100, res.size()), res.end(), resComp);
+
+    std::map<size_t, double> bests;
+    std::map<size_t, size_t> bestToken;
+
+		size_t TOPK = 100;
+
+		// res contains the 100 best token matches
+    for (size_t i = 0; i < res.size() && i < TOPK; i++) {
+      for (size_t j = 0; j < _inv[res[i].first].size(); j++) {
+
+				double score = _inv[res[i].first][j].second * (delta / (1.0 + res[i].second));
+
+				if (score > bests[_inv[res[i].first][j].first]) {
+						bests[_inv[res[i].first][j].first] = score;
+						bestToken[_inv[res[i].first][j].first] = res[i].first;
+				}
+      }
+    }
+
+    for (size_t i = 0; i < res.size() && i < TOPK; i++) {
+			// inv[res[i]] contains all the names the token res[i] occurs in
+
+      lists.push_back(_inv[res[i].first]);
+
+      // give them a score based on their PED
+			for (size_t j = 0; j < lists.back().size(); j++) {
+				double score = lists.back()[j].second *
+                                 (delta / (1.0 + res[i].second));
+				// best is the token for this name that matched best for the input token
+				size_t best = bestToken[lists.back()[j].first];
+
+				// if it is not this token, we dont count it
+				if (res[i].first != best) score = 0;
+        lists.back()[j].second = score;
+			}
+    }
+  }
+
+  std::vector<const TupleList*> mlists;
+  for (const auto& l : lists) mlists.push_back(&l);
+
+  ret = lmerge(mlists);
+
+  TripleList fr;
+
+  for (const auto& r : ret) {
+    fr.push_back({{_nameToGroup.find(r.first)->second, r.first}, r.second});
+  }
+
+  std::sort(fr.begin(), fr.end(), resGidCompInv);
+
+  TripleList fin;
+  for (const auto& r : fr) {
+    if (fin.size() == 0 || fin.back().first.first != r.first.first) fin.push_back(r);
+  }
+
+  std::partial_sort(fin.begin(), fin.begin() + std::min<size_t>(fin.size(), 10),
+                    fin.end(), resCompInv);
+
+  TripleList top10;
+  for (const auto& r : fin) {
+    top10.push_back(r);
+    if (top10.size() == 10) break;
+  }
+
+  return top10;
+}
+
+// _____________________________________________________________________________
+TupleList SearchIdx::tokenFind(const std::wstring& prefix) const {
+  TupleList result;
+
+  size_t delta = prefix.size() / 4;
+
+  std::vector<const TupleList*> lists;
+  for (const auto& qGram : getQGrams(prefix)) {
+    auto it = _qGramIndex.find(qGram);
+    if (it != _qGramIndex.end()) lists.push_back(&it->second);
+  }
+
+  size_t threshold = prefix.size() - 3 * delta;
+
+  for (const auto& tpl : lmerge(lists)) {
+    if (tpl.second >= threshold) {
+      size_t ped = util::prefixEditDist(prefix, _tokens[tpl.first], delta);
+      if (ped <= delta) result.push_back({tpl.first, ped});
+    }
+  }
+
+  return result;
+}
+
+// _____________________________________________________________________________
+TupleList SearchIdx::lmerge(const std::vector<const TupleList*>& lists) {
+  if (lists.size() == 0) return {};
+
+  TupleList a = *lists[0];
+
+  for (size_t k = 1; k < lists.size(); k++) {
+    const auto& b = lists[k];
+
+    TupleList ret;
+    size_t i = 0;
+    size_t j = 0;
+    while (i < a.size() && j < b->size()) {
+      if (a[i].first < (*b)[j].first) {
+        ret.push_back(a[i]);
+        i++;
+      } else if ((*b)[j].first < a[i].first) {
+        ret.push_back((*b)[j]);
+        j++;
+      } else {
+        ret.push_back({a[i].first, a[i].second + (*b)[j].second});
+        i++;
+        j++;
+      }
+    }
+
+    while (i < a.size()) {
+      ret.push_back(a[i]);
+      i++;
+    }
+
+    while (j < b->size()) {
+      ret.push_back((*b)[j]);
+      j++;
+    }
+
+    a = ret;
+  }
+
+  return a;
+}

src/osmfixer/index/SearchIdx.h

@@ -0,0 +1,69 @@
+// Copyright 2019, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>.
+
+#ifndef OSMFIXER_INDEX_SEARCHIDX_H_
+#define OSMFIXER_INDEX_SEARCHIDX_H_
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "osmfixer/index/StatIdx.h"
+
+namespace osmfixer {
+
+
+typedef std::pair<size_t, double> Tuple;
+typedef std::vector<Tuple> TupleList;
+typedef std::pair<std::pair<size_t, size_t>, double> Triple;
+typedef std::vector<Triple> TripleList;
+typedef std::unordered_map<std::wstring, TupleList> Index;
+
+inline bool resComp(const Tuple& lh, const Tuple& rh) {
+  return lh.second < rh.second;
+}
+
+inline bool resCompInv(const Triple& lh, const Triple& rh) {
+  return lh.second > rh.second;
+}
+
+inline bool resGidCompInv(const Triple& lh, const Triple& rh) {
+  if (lh.first.first < rh.first.first) return true;
+  if (lh.first.first == rh.first.first) return lh.second > rh.second;
+  return false;
+}
+
+class SearchIdx {
+ public:
+  explicit SearchIdx(const StatIdx& sidx) : _stats(sidx) { build(); }
+
+  void build();
+
+  TripleList find(const std::string& qry) const;
+
+  static std::wstring normalize(const std::wstring& str);
+  static std::vector<std::wstring> tokenize(const std::wstring& str);
+
+  static std::vector<std::wstring> getQGrams(const std::wstring& word);
+
+  const Index& getIndex() const { return _qGramIndex; }
+
+  const std::string& getName(size_t nid) const { return _names[nid]; }
+
+ private:
+  TupleList tokenFind(const std::wstring& prefix) const;
+  static TupleList lmerge(const std::vector<const TupleList*>& lists);
+
+  const StatIdx& _stats;
+
+  Index _qGramIndex;
+
+  std::unordered_map<size_t, size_t> _nameToGroup;
+  std::vector<std::wstring> _tokens;
+  std::vector<std::string> _names;
+
+  std::vector<TupleList> _inv;
+};
+}  // namespace osmfixer
+
+#endif  // OSMFIXER_INDEX_SEARCHIDX_H_

src/osmfixer/index/StatIdx.cpp

@@ -210,6 +210,7 @@ void StatIdx::addGroup(size_t osmid, const OsmAttrs& attrs) {
 // _____________________________________________________________________________
 void StatIdx::initGroups() {
   for (size_t i = 0; i < _stations.size(); i++) {
+
     // this should be ensured by the input file
     assert(_stations[i].origGroup < _groups.size());
     _groups[_stations[i].origGroup].polyStations.push_back(i);
@@ -228,6 +229,34 @@ void StatIdx::initGroups() {
     }
   }
 
+  // collect unique names
+  for (size_t gid = 0; gid < _groups.size(); gid++) {
+    std::set<std::string> usedGroupNames;
+
+    for (const auto& np : _groups[gid].attrs) {
+      for (const auto& name : np.second) {
+        if (usedGroupNames.count(name)) continue;
+        usedGroupNames.insert(name);
+
+        _groups[gid].uniqueNames.push_back(name);
+      }
+    }
+
+    for (size_t sid :_groups[gid].stations) {
+      for (const auto& np : _stations[sid].attrs) {
+        for (const auto& name : np.second) {
+          // use every name only once to keep the index small
+          if (usedGroupNames.count(name)) continue;
+          usedGroupNames.insert(name);
+
+          _groups[gid].uniqueNames.push_back(name);
+        }
+      }
+    }
+
+    // take the longest name as the identifier
+    std::sort(_groups[gid].uniqueNames.begin(), _groups[gid].uniqueNames.end(), byLen);
+  }
 
   // build hull polygon
   for (size_t i = 0; i < _groups.size(); i++) {
@@ -595,6 +624,46 @@ void StatIdx::initSuggestions() {
       stat.suggestions.push_back(_suggestions.size() - 1);
     }
 
+    Suggestion sug;
+    sug.station = i;
+
+    bool hasStationTrackHeur = false;
+
+    std::set<std::pair<std::string, uint16_t>> suggested;
+    for (auto attrErr : stat.attrErrs) {
+      if (attrErr.fromRel) continue;
+
+      const auto otherStat = getStation(attrErr.otherId);
+      if (stat.id == attrErr.otherId && attrErr.attr == attrErr.otherAttr) {
+        if (suggested.count({attrErr.attr, 8})) continue;
+        hasStationTrackHeur = true;
+        suggested.insert({attrErr.attr, 8});
+        // fix track number as name
+        sug.type = 8;
+        sug.orig_gid = 0;
+        sug.orig_osm_rel_id = 0;
+        sug.target_gid = 0;
+        sug.target_osm_rel_id = 0;
+        sug.attrErrName = attrErr.attr;
+
+        _suggestions.push_back(sug);
+        stat.suggestions.push_back(_suggestions.size() - 1);
+      } else if (otherStat->osmid == stat.osmid) {
+        if (suggested.count({attrErr.attr, 6})) continue;
+        suggested.insert({attrErr.attr, 6});
+        // fix attributes
+        sug.type = 6;
+        sug.orig_gid = 0;
+        sug.orig_osm_rel_id = 0;
+        sug.target_gid = 0;
+        sug.target_osm_rel_id = 0;
+        sug.attrErrName = attrErr.attr;
+
+        _suggestions.push_back(sug);
+        stat.suggestions.push_back(_suggestions.size() - 1);
+      }
+    }
+
     if (stat.group != stat.origGroup || getGroup(stat.group)->osmid == 1) {
       Suggestion sug;
       sug.station = i;
@@ -649,8 +718,11 @@ void StatIdx::initSuggestions() {
 
           _suggestions.push_back(sug);
           stat.suggestions.push_back(_suggestions.size() - 1);
-        } else {
+        } else if (!hasStationTrackHeur) {
           // move station out of relation
+          //
+          // don't show this suggestion if the station track heuristic was
+          // triggered
           sug.type = 5;
           sug.orig_gid = stat.origGroup;
           sug.target_gid = stat.group;
@@ -668,42 +740,6 @@ void StatIdx::initSuggestions() {
       }
     }
 
-    Suggestion sug;
-    sug.station = i;
-
-    std::set<std::pair<std::string, uint16_t>> suggested;
-    for (auto attrErr : stat.attrErrs) {
-      if (attrErr.fromRel) continue;
-
-      const auto otherStat = getStation(attrErr.otherId);
-      if (stat.id == attrErr.otherId && attrErr.attr == attrErr.otherAttr) {
-        if (suggested.count({attrErr.attr, 8})) continue;
-        suggested.insert({attrErr.attr, 8});
-        // fix track number as name
-        sug.type = 8;
-        sug.orig_gid = 0;
-        sug.orig_osm_rel_id = 0;
-        sug.target_gid = 0;
-        sug.target_osm_rel_id = 0;
-        sug.attrErrName = attrErr.attr;
-
-        _suggestions.push_back(sug);
-        stat.suggestions.push_back(_suggestions.size() - 1);
-      } else if (otherStat->osmid == stat.osmid) {
-        if (suggested.count({attrErr.attr, 6})) continue;
-        suggested.insert({attrErr.attr, 6});
-        // fix attributes
-        sug.type = 6;
-        sug.orig_gid = 0;
-        sug.orig_osm_rel_id = 0;
-        sug.target_gid = 0;
-        sug.target_osm_rel_id = 0;
-        sug.attrErrName = attrErr.attr;
-
-        _suggestions.push_back(sug);
-        stat.suggestions.push_back(_suggestions.size() - 1);
-      }
-    }
   }
 }
 

src/osmfixer/index/StatIdx.h

@@ -15,6 +15,10 @@ namespace osmfixer {
 
 typedef std::map<std::string, std::vector<std::string>> OsmAttrs;
 
+inline bool byLen(const std::string& lh, const std::string& rh) {
+  return lh.size() > rh.size();
+}
+
 struct AttrErr {
   std::string attr;
   std::string otherAttr;
@@ -56,6 +60,7 @@ struct Group {
   std::vector<size_t> polyStations;
   std::vector<AttrErr> attrErrs;
   std::vector<size_t> suggestions;
+  std::vector<std::string> uniqueNames;
 };
 
 struct Cluster {
@@ -93,6 +98,10 @@ class StatIdx {
   std::vector<Cluster> getHeatGridErr(const util::geo::DBox bbox,
                                       size_t z) const;
 
+  const std::vector<Station>& getStations() const { return _stations; }
+  const std::vector<Group>& getGroups() const { return _groups; }
+
+
  private:
   void addStation(int64_t osmid, const util::geo::DLine& geom,
                   const util::geo::DLine& latLngs, size_t origGroup,

src/osmfixer/server/StatServer.cpp

@@ -3,6 +3,8 @@
 // Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
 
 #include <vector>
+#include <codecvt>
+#include <locale>
 #include "osmfixer/build.h"
 #include "osmfixer/index.h"
 #include "osmfixer/server/StatServer.h"
@@ -42,6 +44,8 @@ util::http::Answer StatServer::handle(const util::http::Req& req,
       a = handleStatReq(params);
     } else if (cmd == "/group") {
       a = handleGroupReq(params);
+    } else if (cmd == "/search") {
+      a = handleSearch(params);
     } else {
       a = util::http::Answer("404 Not Found", "dunno");
     }
@@ -249,7 +253,8 @@ void StatServer::printStation(const Station* stat, size_t did, bool simple,
   std::string sep = "";
 
   if (simple) {
-      (*out) << sep << "[" << stat->centroid.getY() << "," << stat->centroid.getX() << "]";
+    (*out) << sep << "[" << stat->centroid.getY() << ","
+           << stat->centroid.getX() << "]";
   } else {
     for (const auto& ll : stat->latLng) {
       (*out) << sep << "[" << ll.getY() << "," << ll.getX() << "]";
@@ -259,11 +264,9 @@ void StatServer::printStation(const Station* stat, size_t did, bool simple,
 
   (*out) << "]";
 
-  if (stat->suggestions.size() > 0)
-    (*out) << ",\"s\":1";
+  if (stat->suggestions.size() > 0) (*out) << ",\"s\":1";
 
-  if (stat->attrErrs.size())
-    (*out) << ",\"e\":" << stat->attrErrs.size();
+  if (stat->attrErrs.size()) (*out) << ",\"e\":" << stat->attrErrs.size();
 
   (*out) << "}";
 }
@@ -279,7 +282,7 @@ void StatServer::printSugg(const Suggestion* sugg, size_t did,
     projArrow.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
   }
 
-  (*out) << "{\"i\":" << sugg->station + range.suggIdStart
+  (*out) << "{\"i\":" << sugg->station + range.sidStart
          << ",\"t\":" << sugg->type << ",\"a\":[";
   char sep = ' ';
   for (const auto& p : projArrow) {
@@ -298,7 +301,8 @@ void StatServer::printGroup(const Group* group, size_t did, bool simple,
   (*out) << "{\"i\":" << group->id + range.gidStart << ",\"g\":[";
   char sep = ' ';
   if (simple) {
-    (*out) << sep << "[" << group->centroid.getY() << "," << group->centroid.getX() << "]";
+    (*out) << sep << "[" << group->centroid.getY() << ","
+           << group->centroid.getX() << "]";
   } else {
     for (const auto& p : group->llPoly.getOuter()) {
       (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
@@ -308,11 +312,9 @@ void StatServer::printGroup(const Group* group, size_t did, bool simple,
   (*out) << "]";
   if (group->osmid == 1) (*out) << ",\"n\":1";
 
-  if (group->suggestions.size() > 0)
-    (*out) << ",\"s\":1";
+  if (group->suggestions.size() > 0) (*out) << ",\"s\":1";
 
-  if (group->attrErrs.size())
-    (*out) << ",\"e\":" << group->attrErrs.size();
+  if (group->attrErrs.size()) (*out) << ",\"e\":" << group->attrErrs.size();
   (*out) << "}";
 }
 
@@ -326,7 +328,7 @@ std::string StatServer::parseUrl(std::string u, std::string pl,
     for (const auto& kv : kvs) {
       auto kvp = util::split(kv, '=');
       if (kvp.size() == 1) kvp.push_back("");
-      (*params)[util::urlDecode(kvp[0])] = kvp[1];
+      (*params)[util::urlDecode(kvp[0])] = util::urlDecode(kvp[1]);
     }
   }
 
@@ -335,7 +337,7 @@ std::string StatServer::parseUrl(std::string u, std::string pl,
   for (const auto& kv : kvs) {
     auto kvp = util::split(kv, '=');
     if (kvp.size() == 1) kvp.push_back("");
-    (*params)[util::urlDecode(kvp[0])] = kvp[1];
+    (*params)[util::urlDecode(kvp[0])] = util::urlDecode(kvp[1]);
   }
 
   return util::urlDecode(parts.front());
@@ -372,6 +374,57 @@ size_t StatServer::getDidByGid(size_t gid) const {
 }
 
 // _____________________________________________________________________________
+util::http::Answer StatServer::handleSearch(const Params& pars) const {
+  if (pars.count("q") == 0)
+    throw std::invalid_argument("No query given.");
+  std::string cb;
+  if (pars.count("cb")) cb = pars.find("cb")->second.c_str();
+
+  std::string query = pars.find("q")->second.c_str();
+
+  auto results = _searchIdx.find(query);
+
+  std::stringstream json;
+
+  json << std::setprecision(10);
+
+  if (cb.size()) json << cb << "(";
+  json << "[";
+
+  std::string sep = "";
+  for (const auto& res : results) {
+    size_t gid = res.first.first;
+    size_t did = getDidByGid(gid);
+
+    const auto& range = _idxs[did].first;
+    const auto& idx = _idxs[did].second;
+    size_t idxGid = gid - range.gidStart;
+    const auto group = idx.getGroup(idxGid);
+    json << sep << "{\"gid\":" << gid << ",\"score\":" << res.second << ", \"name\":";
+    std::string name = group->uniqueNames.front();
+    json << "\"" << util::jsonStringEscape(name) << "\"";
+    std::string via = _searchIdx.getName(res.first.second);
+    if (name != via) {
+      json << ",\"via\":" << "\"" << util::jsonStringEscape(via) << "\"";
+    }
+
+    json << ",\"latlng\":{\"lat\":" << group->centroid.getY() << ",\"lng\":" << group->centroid.getX() <<"}";
+
+    sep = ",";
+    json << "}";
+  }
+
+  json << "]";
+
+  if (cb.size()) json << ")";
+
+  auto answ = util::http::Answer("200 OK", json.str(), true);
+  answ.params["Content-Type"] = "application/javascript; charset=utf-8";
+
+  return answ;
+}
+
+// _____________________________________________________________________________
 util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
   if (pars.count("id") == 0 || pars.find("id")->second.empty())
     throw std::invalid_argument("No ID specified.");
@@ -420,13 +473,14 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
   sep = ' ';
   for (const auto& err : group->attrErrs) {
     // self errors denote names named as tracks
-    if (err.fromRel && err.otherId == group->id && err.attr == err.otherAttr) continue;
+    if (err.fromRel && err.otherId == group->id && err.attr == err.otherAttr)
+      continue;
 
     json << sep;
     sep = ',';
     json << "{";
-    json << "\"attr\":[\"" << err.attr << "\",\"" << group->attrs.at(err.attr)[0]
-         << "\"]";
+    json << "\"attr\":[\"" << err.attr << "\",\""
+         << group->attrs.at(err.attr)[0] << "\"]";
     json << ",\"conf\":" << err.conf;
 
     if (err.fromRel) {
@@ -476,11 +530,9 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
       json << "]";
     }
     json << "}";
-    if (stat->suggestions.size() > 0)
-      json << ",\"s\":1";
+    if (stat->suggestions.size() > 0) json << ",\"s\":1";
 
-    if (stat->attrErrs.size())
-      json << ",\"e\":" << stat->attrErrs.size();
+    if (stat->attrErrs.size()) json << ",\"e\":" << stat->attrErrs.size();
     json << "}";
   }
 
@@ -491,20 +543,20 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
   std::string seper = "";
 
   for (size_t sid : group->suggestions) {
-      const auto* sugg = idx.getSuggestion(sid);
-      if (sugg->type == 6) {
-       json << seper << "{\"type\":6,\"attr\":\"" << sugg->attrErrName << "\""
-            << "}";
-      } else if (sugg->type == 7) {
-        json << seper << "{\"type\":7}";
-      } else if (sugg->type == 8) {
-       json << seper << "{\"type\":8,\"attr\":\"" << sugg->attrErrName << "\""
-            << "}";
-      } else {
-        json << seper << "{\"type\":" << sugg->type << "}";
-      }
-      seper = ',';
+    const auto* sugg = idx.getSuggestion(sid);
+    if (sugg->type == 6) {
+      json << seper << "{\"type\":6,\"attr\":\"" << sugg->attrErrName << "\""
+           << "}";
+    } else if (sugg->type == 7) {
+      json << seper << "{\"type\":7}";
+    } else if (sugg->type == 8) {
+      json << seper << "{\"type\":8,\"attr\":\"" << sugg->attrErrName << "\""
+           << "}";
+    } else {
+      json << seper << "{\"type\":" << sugg->type << "}";
     }
+    seper = ',';
+  }
 
   json << "]";
 
@@ -571,7 +623,8 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
   sep = ' ';
   for (const auto& err : stat->attrErrs) {
     // self errors denote names named as tracks
-    if (!err.fromRel && err.otherId == stat->id && err.attr == err.otherAttr) continue;
+    if (!err.fromRel && err.otherId == stat->id && err.attr == err.otherAttr)
+      continue;
     json << sep;
     sep = ',';
     json << "{";
@@ -603,42 +656,47 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
   std::string seper = "";
 
   for (size_t sid : stat->suggestions) {
-      const auto* sugg = idx.getSuggestion(sid);
-      if (sugg->type == 1) {
-        json << seper << "{\"type\":1, \"target_gid\":" << stat->group + range.gidStart
-             << "}";
-      } else if (sugg->type == 2) {
-        json << seper << "{\"type\":2, \"target_gid\":" << stat->group + range.gidStart
-             << ",\"target_osm_rel_id\":" << idx.getGroup(stat->group)->osmid
-             << "}";
-      } else if (sugg->type == 3) {
-        json << seper << "{\"type\":3,\"orig_gid\":" << stat->origGroup + range.gidStart
-             << ",\"orig_osm_rel_id\":" << idx.getGroup(stat->origGroup)->osmid
-             << ",\"target_gid\":" << stat->group + range.gidStart << "}";
-      } else if (sugg->type == 4) {
-        json << seper << "{\"type\":4,\"orig_gid\":" << stat->origGroup + range.gidStart
-             << ",\"orig_osm_rel_id\":" << idx.getGroup(stat->origGroup)->osmid
-             << ",\"target_gid\":" << stat->group << ",\"target_osm_rel_id\":"
-             << idx.getGroup(stat->group)->osmid + range.gidStart << "}";
-      } else if (sugg->type == 5) {
-        json << seper << "{\"type\":5,\"orig_gid\":" << stat->origGroup + range.gidStart
-             << ",\"orig_osm_rel_id\":" << idx.getGroup(stat->origGroup)->osmid
-             << ",\"target_gid\":" << stat->group + range.gidStart
-             << ",\"target_osm_rel_id\":" << idx.getGroup(stat->group)->osmid
-             << "}";
-      } else if (sugg->type == 6) {
-       json << seper << "{\"type\":6,\"attr\":\"" << sugg->attrErrName << "\""
-            << "}";
-      } else if (sugg->type == 7) {
-        json << seper << "{\"type\":7}";
-      } else if (sugg->type == 8) {
-       json << seper << "{\"type\":8,\"attr\":\"" << sugg->attrErrName << "\""
-            << "}";
-      } else {
-        json << seper << "{\"type\":" << sugg->type << "}";
-      }
-      seper = ',';
+    const auto* sugg = idx.getSuggestion(sid);
+    if (sugg->type == 1) {
+      json << seper
+           << "{\"type\":1, \"target_gid\":" << stat->group + range.gidStart
+           << "}";
+    } else if (sugg->type == 2) {
+      json << seper
+           << "{\"type\":2, \"target_gid\":" << stat->group + range.gidStart
+           << ",\"target_osm_rel_id\":" << idx.getGroup(stat->group)->osmid
+           << "}";
+    } else if (sugg->type == 3) {
+      json << seper
+           << "{\"type\":3,\"orig_gid\":" << stat->origGroup + range.gidStart
+           << ",\"orig_osm_rel_id\":" << idx.getGroup(stat->origGroup)->osmid
+           << ",\"target_gid\":" << stat->group + range.gidStart << "}";
+    } else if (sugg->type == 4) {
+      json << seper
+           << "{\"type\":4,\"orig_gid\":" << stat->origGroup + range.gidStart
+           << ",\"orig_osm_rel_id\":" << idx.getGroup(stat->origGroup)->osmid
+           << ",\"target_gid\":" << stat->group << ",\"target_osm_rel_id\":"
+           << idx.getGroup(stat->group)->osmid + range.gidStart << "}";
+    } else if (sugg->type == 5) {
+      json << seper
+           << "{\"type\":5,\"orig_gid\":" << stat->origGroup + range.gidStart
+           << ",\"orig_osm_rel_id\":" << idx.getGroup(stat->origGroup)->osmid
+           << ",\"target_gid\":" << stat->group + range.gidStart
+           << ",\"target_osm_rel_id\":" << idx.getGroup(stat->group)->osmid
+           << "}";
+    } else if (sugg->type == 6) {
+      json << seper << "{\"type\":6,\"attr\":\"" << sugg->attrErrName << "\""
+           << "}";
+    } else if (sugg->type == 7) {
+      json << seper << "{\"type\":7}";
+    } else if (sugg->type == 8) {
+      json << seper << "{\"type\":8,\"attr\":\"" << sugg->attrErrName << "\""
+           << "}";
+    } else {
+      json << seper << "{\"type\":" << sugg->type << "}";
     }
+    seper = ',';
+  }
 
   json << "]";
 

src/osmfixer/server/StatServer.h

@@ -8,6 +8,7 @@
 #include <map>
 #include <string>
 #include "osmfixer/index/StatIdx.h"
+#include "osmfixer/index/SearchIdx.h"
 #include "util/http/Server.h"
 
 namespace osmfixer {
@@ -21,8 +22,8 @@ typedef std::map<std::string, std::string> Params;
 class StatServer : public util::http::Handler {
  public:
   explicit StatServer(
-      const std::vector<std::pair<IdRange, osmfixer::StatIdx>>& idxs)
-      : _idxs(idxs) {}
+      const std::vector<std::pair<IdRange, osmfixer::StatIdx>>& idxs, const SearchIdx& searchIdx)
+      : _idxs(idxs), _searchIdx(searchIdx) {}
 
   virtual util::http::Answer handle(const util::http::Req& request,
                                     int connection) const;
@@ -34,6 +35,7 @@ class StatServer : public util::http::Handler {
   util::http::Answer handleHeatMapReq(const Params& pars) const;
   util::http::Answer handleStatReq(const Params& pars) const;
   util::http::Answer handleGroupReq(const Params& pars) const;
+  util::http::Answer handleSearch(const Params& pars) const;
 
   void printStation(const Station* stat, size_t did, bool simple, std::ostream* out) const;
   void printGroup(const Group* stat, size_t did, bool simple, std::ostream* out) const;
@@ -44,6 +46,7 @@ class StatServer : public util::http::Handler {
   size_t getDidByGid(size_t gid) const;
 
   const std::vector<std::pair<IdRange, osmfixer::StatIdx>>& _idxs;
+  const SearchIdx& _searchIdx;
 };
 }  // namespace osmfixer
 

src/util/Misc.h

@@ -9,15 +9,25 @@
 #include <cstring>
 #include <chrono>
 #include <sstream>
+#include <iostream>
 #include <unistd.h>
 #include <sys/types.h>
 #include <pwd.h>
 
 #define UNUSED(expr) do { (void)(expr); } while (0)
 #define TIME() std::chrono::high_resolution_clock::now()
-#define TOOK(t1, t2) (std::chrono::duration_cast<microseconds>(t2 - t1).count() / 1000.0)
+#define TOOK(t1, t2) (std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count() / 1000.0)
 #define T_START(n)  auto _tstart_##n = std::chrono::high_resolution_clock::now()
-#define T_STOP(n) (std::chrono::duration_cast<microseconds>(std::chrono::high_resolution_clock::now() - _tstart_##n).count() / 1000.0)
+#define T_STOP(n) (std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - _tstart_##n).count() / 1000.0)
+
+#define _TEST3(s, o, e) if (!(s o e)) {  std::cerr << "\n" << __FILE__ << ":" << __LINE__ << ": Test failed!\n  Expected " << #s << " " << #o " " << (e) << ", got " << (s) << std::endl;  exit(1);}
+#define _TEST2(s, e) _TEST3(s, ==, o)
+#define _TEST1(s) _TEST3(static_cast<bool>(s), ==, true)
+
+#define _GET_TEST_MACRO(_1,_2,_3,NAME,...) NAME
+#define TEST(...) _GET_TEST_MACRO(__VA_ARGS__, _TEST3, _TEST2, _TEST1)(__VA_ARGS__)
+
+#define TODO(msg) std::cerr << "\n" __FILE__ << ":" << __LINE__ << ": TODO: " << #msg << std::endl;
 
 namespace util {
 
@@ -28,7 +38,7 @@ static int pow10[10] = {
 
 // _____________________________________________________________________________
 inline uint64_t factorial(uint64_t n) {
-  if (n == 1) return n;
+  if (n < 2) return 1;
   return n * factorial(n - 1);
 }
 
@@ -131,6 +141,55 @@ inline std::string getTmpDir() {
   return getHomeDir();
 }
 
+// _____________________________________________________________________________
+class approx {
+ public:
+  explicit approx(double magnitude)
+      : _epsilon{std::numeric_limits<float>::epsilon() * 100},
+        _magnitude{magnitude} {}
+
+  friend bool operator==(double lhs, approx const& rhs) {
+    return std::abs(lhs - rhs._magnitude) < rhs._epsilon;
+  }
+
+  friend bool operator==(approx const& lhs, double rhs) {
+    return operator==(rhs, lhs);
+  }
+
+  friend bool operator!=(double lhs, approx const& rhs) {
+    return !operator==(lhs, rhs);
+  }
+
+  friend bool operator!=(approx const& lhs, double rhs) {
+    return !operator==(rhs, lhs);
+  }
+
+  friend bool operator<=(double lhs, approx const& rhs) {
+    return lhs < rhs._magnitude || lhs == rhs;
+  }
+
+  friend bool operator<=(approx const& lhs, double rhs) {
+    return lhs._magnitude < rhs || lhs == rhs;
+  }
+
+  friend bool operator>=(double lhs, approx const& rhs) {
+    return lhs > rhs._magnitude || lhs == rhs;
+  }
+
+  friend bool operator>=(approx const& lhs, double rhs) {
+    return lhs._magnitude > rhs || lhs == rhs;
+  }
+
+  friend std::ostream& operator<< (std::ostream &out, const approx &a) {
+    out << "~" << a._magnitude;
+    return out;
+  }
+
+ private:
+  double _epsilon;
+  double _magnitude;
+};
+
 }  // namespace util
 
 #endif  // UTIL_MISC_H_

src/util/String.h

@@ -6,7 +6,9 @@
 #define UTIL_STRING_H_
 
 #include <algorithm>
+#include <cassert>
 #include <cstring>
+#include <iomanip>
 #include <sstream>
 #include <string>
 #include <vector>
@@ -36,18 +38,43 @@ inline std::string urlDecode(const std::string& encoded) {
 }
 
 // _____________________________________________________________________________
-inline std::string jsonStringEscape(const std::string& unescaped) {
-  std::string escaped;
-  for (size_t i = 0; i < unescaped.size(); ++i) {
-    if (unescaped[i] == '"' || unescaped[i] == '\\') {
-      escaped += "\\";
+inline std::string jsonStringEscape(const std::string& unesc) {
+  // modified code from
+  // http://stackoverflow.com/questions/7724448/simple-json-string-escape-for-c
+  std::ostringstream o;
+  for (auto c = unesc.cbegin(); c != unesc.cend(); c++) {
+    switch (*c) {
+      case '"':
+        o << "\\\"";
+        break;
+      case '\\':
+        o << "\\\\";
+        break;
+      case '\b':
+        o << "\\b";
+        break;
+      case '\f':
+        o << "\\f";
+        break;
+      case '\n':
+        o << "\\n";
+        break;
+      case '\r':
+        o << "\\r";
+        break;
+      case '\t':
+        o << "\\t";
+        break;
+      default:
+        if ('\x00' <= *c && *c <= '\x1f') {
+          o << "\\u" << std::hex << std::setw(4) << std::setfill('0')
+            << static_cast<int>(*c);
+        } else {
+          o << *c;
+        }
     }
-    if (iscntrl(unescaped[i])) {
-      escaped += " ";
-    }
-    escaped += unescaped[i];
   }
-  return escaped;
+  return o.str();
 }
 
 // _____________________________________________________________________________
@@ -143,7 +170,8 @@ inline size_t editDist(const std::string& s1, const std::string& s2) {
 }
 
 // _____________________________________________________________________________
-inline size_t prefixEditDist(const std::string& prefix, const std::string& s,
+template <class String>
+inline size_t prefixEditDist(const String& prefix, const String& s,
                              size_t deltaMax) {
   // https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C++
   size_t len1 = prefix.size();
@@ -152,38 +180,76 @@ inline size_t prefixEditDist(const std::string& prefix, const std::string& s,
 
   d[0] = 0;
   for (size_t i = 1; i <= len1; ++i) d[i * (len2 + 1)] = i;
-  for (size_t i = 1; i <= len2; ++i) d[ i] = i;
+  for (size_t i = 1; i <= len2; ++i) d[i] = i;
 
   for (size_t i = 1; i <= len1; i++) {
     for (size_t j = 1; j <= len2; j++) {
-      d[i * (len2 + 1) + j] = std::min(std::min(d[(i - 1) * (len2 + 1) + j] + 1, d[i * (len2 + 1) + j - 1] + 1),
-                         d[(i - 1) * (len2 + 1) + j - 1] + (prefix[i - 1] == s[j - 1] ? 0 : 1));
+      d[i * (len2 + 1) + j] = std::min(std::min(d[(i - 1) * (len2 + 1) + j] + 1,
+                                                d[i * (len2 + 1) + j - 1] + 1),
+                                       d[(i - 1) * (len2 + 1) + j - 1] +
+                                           (prefix[i - 1] == s[j - 1] ? 0 : 1));
     }
   }
 
   // take min of last row
   size_t deltaMin = std::max(std::max(deltaMax + 1, prefix.size()), s.size());
   for (size_t i = 0; i <= len2; i++) {
-    if (d[len1 * (len2 + 1) + i] < deltaMin) deltaMin = d[len1 * (len2 + 1) + i];
+    if (d[len1 * (len2 + 1) + i] < deltaMin)
+      deltaMin = d[len1 * (len2 + 1) + i];
   }
 
   return deltaMin;
 }
 
 // _____________________________________________________________________________
-inline size_t prefixEditDist(const std::string& prefix, const std::string& s) {
+template <class String>
+inline size_t prefixEditDist(const String& prefix, const String& s) {
   return prefixEditDist(prefix, s, s.size());
 }
 
 // _____________________________________________________________________________
+inline size_t prefixEditDist(const char* prefix, const char* s) {
+  return prefixEditDist<std::string>(std::string(prefix), std::string(s));
+}
+
+// _____________________________________________________________________________
+inline size_t prefixEditDist(const char* prefix, const char* s,
+                             size_t deltaMax) {
+  return prefixEditDist<std::string>(std::string(prefix), std::string(s),
+                                     deltaMax);
+}
+
+// _____________________________________________________________________________
+inline size_t prefixEditDist(const char* prefix, const std::string& s) {
+  return prefixEditDist<std::string>(std::string(prefix), s);
+}
+
+// _____________________________________________________________________________
+inline size_t prefixEditDist(const char* prefix, const std::string& s,
+                             size_t deltaMax) {
+  return prefixEditDist<std::string>(std::string(prefix), s, deltaMax);
+}
+
+// _____________________________________________________________________________
+inline size_t prefixEditDist(const std::string& prefix, const char* s) {
+  return prefixEditDist<std::string>(prefix, std::string(s));
+}
+
+// _____________________________________________________________________________
+inline size_t prefixEditDist(const std::string& prefix, const char* s,
+                             size_t deltaMax) {
+  return prefixEditDist<std::string>(prefix, std::string(s), deltaMax);
+}
+
+// _____________________________________________________________________________
 inline std::string toUpper(std::string str) {
-  std::transform(str.begin(), str.end(),str.begin(), toupper);
+  std::transform(str.begin(), str.end(), str.begin(), toupper);
   return str;
 }
 
 // _____________________________________________________________________________
 inline std::string toLower(std::string str) {
-  std::transform(str.begin(), str.end(),str.begin(), tolower);
+  std::transform(str.begin(), str.end(), str.begin(), tolower);
   return str;
 }
 
@@ -226,6 +292,6 @@ template <typename T>
 inline std::string implode(const std::vector<T>& vec, const char* del) {
   return implode(vec.begin(), vec.end(), del);
 }
-}
+}  // namespace util
 
 #endif  // UTIL_STRING_H_

src/util/geo/BezierCurve.tpp

@@ -64,7 +64,7 @@ const PolyLine<T>& BezierCurve<T>::render(double d) {
 }
 
 // _____________________________________________________________________________
-double CubicPolynom::valueAt(double atx) const {
+inline double CubicPolynom::valueAt(double atx) const {
   double dx = atx - x;
   return a + b * dx + c * dx * dx + d * dx * dx * dx;
 }

src/util/geo/CircularSegment.h

@@ -0,0 +1,41 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_CIRCULARSEGMENT_H_
+#define UTIL_GEO_CIRCULARSEGMENT_H_
+
+#include <vector>
+#include "util/geo/Geo.h"
+#include "util/geo/PolyLine.h"
+
+namespace util {
+namespace geo {
+
+/**
+ * Circular segment
+ */
+template <typename T>
+class CircularSegment {
+ public:
+  CircularSegment(const Point<T>& a, double ang, const Point<T>& c);
+
+  const PolyLine<T>& render(double d);
+
+ private:
+  // store the rendered polyline for quicker access
+  PolyLine<T> _rendered;
+
+  const Point<T>& _a, _c;
+  double _renderD;
+
+  double _ang, _rad, _s, _initAng;
+
+  Point<T> valueAt(double t) const;
+};
+
+#include "util/geo/CircularSegment.tpp"
+}
+}
+
+#endif  // UTIL_GEO_BEZIERCURVE_H_

src/util/geo/CircularSegment.tpp

@@ -0,0 +1,51 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename T>
+CircularSegment<T>::CircularSegment(const Point<T>& a, double ang,
+                            const Point<T>& c) : _a(a), _c(c), _renderD(0), _ang(ang)
+     {
+
+  _rad = dist(a, c);
+  _s = fabs(_ang * _rad);
+  _initAng = angBetween(c, a);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Point<T> CircularSegment<T>::valueAt(double ang) const {
+  double xPos = _c.getX() + _rad * cos(ang);
+  double yPos = _c.getY() + _rad * sin(ang);
+  return Point<T>(xPos, yPos);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+const PolyLine<T>& CircularSegment<T>::render(double d) {
+  assert(d > 0);
+  if (fabs(d - _renderD) < 0.001) return _rendered;
+  _renderD = d;
+
+  if (_s == 0) {
+    _rendered << _a << _a;
+    return _rendered;
+  }
+
+  _rendered.empty();
+  double n = _s / d, dt = 1 / n, t = 0;
+
+  bool cancel = false;
+  while (true) {
+    _rendered << valueAt(_initAng + t * _ang);
+    t += dt;
+    if (cancel) break;
+    if (t > 1) {
+      t = 1;
+      cancel = true;
+    }
+  }
+
+  return _rendered;
+}

src/util/geo/Geo.h

@@ -51,6 +51,7 @@ typedef Polygon<int> IPolygon;
 
 const static double EPSILON = 0.00001;
 const static double RAD = 0.017453292519943295;  // PI/180
+const static double AVERAGING_STEP = 20;
 
 // _____________________________________________________________________________
 template <typename T>
@@ -204,6 +205,14 @@ inline Polygon<T> move(Polygon<T> geo, double x, double y) {
 }
 
 // _____________________________________________________________________________
+template <typename T>
+inline Box<T> move(Box<T> geo, double x, double y) {
+  geo.setLowerLeft(move(geo.getLowerLeft(), x, y));
+  geo.setUpperRight(move(geo.getUpperRight(), x, y));
+  return geo;
+}
+
+// _____________________________________________________________________________
 template <template <typename> class Geometry, typename T>
 inline std::vector<Geometry<T>> move(std::vector<Geometry<T>> multigeo,
                                      double x, double y) {
@@ -356,8 +365,9 @@ inline bool contains(const Polygon<T>& polyC, const Polygon<T>& poly) {
   }
 
   // also check the last hop
-  if (!contains(LineSegment<T>(polyC.getOuter().back(), polyC.getOuter().front()),
-                poly))
+  if (!contains(
+          LineSegment<T>(polyC.getOuter().back(), polyC.getOuter().front()),
+          poly))
     return false;
 
   return true;
@@ -628,6 +638,34 @@ inline bool intersects(const Box<T>& b, const Point<T>& p) {
 }
 
 // _____________________________________________________________________________
+template <template <typename> class GeometryA,
+          template <typename> class GeometryB, typename T>
+inline bool intersects(const std::vector<GeometryA<T>>& multigeom,
+                       const GeometryB<T>& b) {
+  for (const auto& geom : multigeom)
+    if (intersects(geom, b)) return true;
+  return false;
+}
+
+// _____________________________________________________________________________
+template <template <typename> class GeometryA,
+          template <typename> class GeometryB, typename T>
+inline bool intersects(const GeometryB<T>& b,
+                       const std::vector<GeometryA<T>>& multigeom) {
+  return intersects(multigeom, b);
+}
+
+// _____________________________________________________________________________
+template <template <typename> class GeometryA,
+          template <typename> class GeometryB, typename T>
+inline bool intersects(const std::vector<GeometryA<T>>& multigeomA,
+                       const std::vector<GeometryA<T>>& multigeomB) {
+  for (const auto& geom : multigeomA)
+    if (intersects(geom, multigeomB)) return true;
+  return false;
+}
+
+// _____________________________________________________________________________
 template <typename T>
 inline Point<T> intersection(T p1x, T p1y, T q1x, T q1y, T p2x, T p2y, T q2x,
                              T q2y) {
@@ -778,6 +816,36 @@ inline double dist(const Line<T>& la, const Line<T>& lb) {
 }
 
 // _____________________________________________________________________________
+template <template <typename> class GeometryA,
+          template <typename> class GeometryB, typename T>
+inline double dist(const std::vector<GeometryA<T>>& multigeom,
+                   const GeometryB<T>& b) {
+  double d = std::numeric_limits<double>::infinity();
+  for (const auto& geom : multigeom)
+    if (dist(geom, b) < d) d = dist(geom, b);
+  return d;
+}
+
+// _____________________________________________________________________________
+template <template <typename> class GeometryA,
+          template <typename> class GeometryB, typename T>
+inline double dist(const GeometryB<T>& b,
+                   const std::vector<GeometryA<T>>& multigeom) {
+  return dist(multigeom, b);
+}
+
+// _____________________________________________________________________________
+template <template <typename> class GeometryA,
+          template <typename> class GeometryB, typename T>
+inline double dist(const std::vector<GeometryA<T>>& multigeomA,
+                   const std::vector<GeometryB<T>>& multigeomB) {
+  double d = std::numeric_limits<double>::infinity();
+  for (const auto& geom : multigeomB)
+    if (dist(geom, multigeomA) < d) d = dist(geom, multigeomA);
+  return d;
+}
+
+// _____________________________________________________________________________
 inline double innerProd(double x1, double y1, double x2, double y2, double x3,
                         double y3) {
   double dx21 = x2 - x1;
@@ -1242,6 +1310,40 @@ inline Box<T> getBoundingBox(const std::vector<Geometry<T>>& multigeo) {
 
 // _____________________________________________________________________________
 template <typename T>
+inline double getEnclosingRadius(const Point<T>& p, const Point<T>& pp) {
+  return dist(p, pp);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline double getEnclosingRadius(const Point<T>& p, const Line<T>& l) {
+  double ret = 0;
+  for (const auto& pp : l)
+    if (getEnclosingRadius(p, pp) > ret) ret = getEnclosingRadius(p, pp);
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline double getEnclosingRadius(const Point<T>& p, const Polygon<T>& pg) {
+  double ret = 0;
+  for (const auto& pp : pg.getOuter())
+    if (getEnclosingRadius(p, pp) > ret) ret = getEnclosingRadius(p, pp);
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <template <typename> class Geometry, typename T>
+inline double getEnclosingRadius(const Point<T>& p,
+                                 const std::vector<Geometry<T>>& multigeom) {
+  double ret = 0;
+  for (const auto& pp : multigeom)
+    if (getEnclosingRadius(p, pp) > ret) ret = getEnclosingRadius(p, pp);
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
 inline Polygon<T> convexHull(const Point<T>& p) {
   return Polygon<T>({p});
 }
@@ -1277,7 +1379,7 @@ inline size_t convexHullImpl(const MultiPoint<T>& a, size_t p1, size_t p2,
   for (const auto& p : a) {
     double tmpDist = distToSegment((*h)[p1], (*h)[p2], p);
     double cp = crossProd(p, LineSegment<T>((*h)[p1], (*h)[p2]));
-    if ((cp > 0) && tmpDist > maxDist) {
+    if ((cp > 0 + EPSILON) && tmpDist > maxDist) {
       pa = p;
       found = true;
       maxDist = tmpDist;
@@ -1308,7 +1410,7 @@ inline Polygon<T> convexHull(const MultiPoint<T>& l) {
   convexHullImpl(l, 0, 1, &hull);
   hull.push_back(hull.front());
   convexHullImpl(l, hull.size() - 2, hull.size() - 1, &hull);
-	hull.pop_back();
+  hull.pop_back();
 
   return Polygon<T>(hull);
 }
@@ -1357,6 +1459,181 @@ inline Box<T> extendBox(const std::vector<Geometry<T>>& multigeom, Box<T> b) {
 
 // _____________________________________________________________________________
 template <typename T>
+Point<T> pointAt(const Line<T> l, double at) {
+  return pointAtDist(l, at * len(l));
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Point<T> pointAt(const Line<T> l, double at, size_t* lastI, double* totPos) {
+  return pointAtDist(l, at * len(l), lastI, totPos);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Point<T> pointAtDist(const Line<T> l, double atDist) {
+  return pointAtDist(l, atDist, 0, 0);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Point<T> pointAtDist(const Line<T> l, double atDist, size_t* lastI,
+                     double* totPos) {
+  if (l.size() == 1) {
+    if (lastI) *lastI = 0;
+    if (totPos) *totPos = 0;
+    return l[1];
+  }
+
+  if (atDist > geo::len(l)) atDist = geo::len(l);
+  if (atDist < 0) atDist = 0;
+
+  double dist = 0;
+
+  const Point<T>* last = &l[0];
+
+  for (size_t i = 1; i < l.size(); i++) {
+    const Point<T>& cur = l[i];
+    double d = geo::dist(*last, cur);
+    dist += d;
+
+    if (dist > atDist) {
+      double p = (d - (dist - atDist));
+      if (lastI) *lastI = i - 1;
+      if (totPos) *totPos = atDist / util::geo::len(l);
+      return interpolate(*last, cur, p / dist);
+    }
+
+    last = &l[i];
+  }
+
+  if (lastI) *lastI = l.size() - 1;
+  if (totPos) *totPos = 1;
+  return l.back();
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Point<T> interpolate(const Point<T>& a, const Point<T>& b, double d) {
+  double n1 = b.getX() - a.getX();
+  double n2 = b.getY() - a.getY();
+  return Point<T>(a.getX() + (n1 * d), a.getY() + (n2 * d));
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Line<T> orthoLineAtDist(const Line<T>& l, double d, double length) {
+  Point<T> avgP = pointAtDist(l, d);
+
+  double angle = angBetween(pointAtDist(l, d - 5), pointAtDist(l, d + 5));
+
+  double angleX1 = avgP.getX() + cos(angle + M_PI / 2) * length / 2;
+  double angleY1 = avgP.getY() + sin(angle + M_PI / 2) * length / 2;
+
+  double angleX2 = avgP.getX() + cos(angle + M_PI / 2) * -length / 2;
+  double angleY2 = avgP.getY() + sin(angle + M_PI / 2) * -length / 2;
+
+  return Line<T>{Point<T>(angleX1, angleY1), Point<T>(angleX2, angleY2)};
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Line<T> segment(const Line<T>& line, double a, double b) {
+  if (a > b) {
+    double c = a;
+    a = b;
+    b = c;
+  }
+  size_t startI, endI;
+  auto start = pointAt(line, a, &startI, 0);
+  auto end = pointAt(line, b, &endI, 0);
+
+  return segment(line, start, startI, end, endI);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Line<T> segment(const Line<T>& line, const Point<T>& start, size_t startI,
+                const Point<T>& end, size_t endI) {
+  Line<T> ret;
+  ret.push_back(start);
+
+  if (startI + 1 <= endI) {
+    ret.insert(ret.end(), line.begin() + startI + 1, line.begin() + endI + 1);
+  }
+  ret.push_back(end);
+
+  // find a more performant way to clear the result of above
+  ret = util::geo::simplify(ret, 0);
+
+  assert(ret.size());
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Line<T> average(const std::vector<const Line<T>*>& lines) {
+  return average(lines, std::vector<double>());
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Line<T> average(const std::vector<const Line<T>*>& lines,
+                const std::vector<double>& weights) {
+  bool weighted = lines.size() == weights.size();
+  double stepSize;
+
+  double longestLength =
+      std::numeric_limits<double>::min();  // avoid recalc of length on each
+                                           // comparision
+  for (auto p : lines) {
+    if (len(*p) > longestLength) {
+      longestLength = len(*p);
+    }
+  }
+
+  Line<T> ret;
+  double total = 0;
+
+  for (size_t i = 0; i < lines.size(); ++i) {
+    if (weighted) {
+      total += weights[i];
+    } else {
+      total += 1;
+    }
+  }
+
+  stepSize = AVERAGING_STEP / longestLength;
+  bool end = false;
+  for (double a = 0; !end; a += stepSize) {
+    if (a > 1) {
+      a = 1;
+      end = true;
+    }
+    double x = 0, y = 0;
+
+    for (size_t i = 0; i < lines.size(); ++i) {
+      auto pl = lines[i];
+      Point<T> p = pointAt(*pl, a);
+      if (weighted) {
+        x += p.getX() * weights[i];
+        y += p.getY() * weights[i];
+      } else {
+        x += p.getX();
+        y += p.getY();
+      }
+    }
+    ret.push_back(Point<T>(x / total, y / total));
+  }
+
+  simplify(ret, 0);
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
 inline double area(const Point<T>& b) {
   UNUSED(b);
   return 0;
@@ -1624,7 +1901,7 @@ inline double webMercDistFactor(const G& a) {
   double lat = 2 * atan(exp(a.getY() / 6378137.0)) - 1.5707965;
   return cos(lat);
 }
-}
-}
+}  // namespace geo
+}  // namespace util
 
 #endif  // UTIL_GEO_GEO_H_

src/util/geo/Grid.h

@@ -55,6 +55,9 @@ class Grid {
   size_t getXWidth() const;
   size_t getYHeight() const;
 
+  size_t getCellXFromX(double lon) const;
+  size_t getCellYFromY(double lat) const;
+
  private:
   double _width;
   double _height;
@@ -76,9 +79,6 @@ class Grid {
   std::set<V> _removed;
 
   Box<T> getBox(size_t x, size_t y) const;
-
-  size_t getCellXFromX(double lon) const;
-  size_t getCellYFromY(double lat) const;
 };
 
 #include "util/geo/Grid.tpp"

src/util/geo/Grid.tpp

@@ -29,6 +29,7 @@ Grid<V, G, T>::Grid(double w, double h, const Box<T>& bbox, bool bValIdx)
       _cellHeight(fabs(h)),
       _bb(bbox),
       _hasValIdx(bValIdx) {
+
   _width =
       bbox.getUpperRight().getX() - bbox.getLowerLeft().getX();
   _height =
@@ -107,7 +108,7 @@ void Grid<V, G, T>::get(const G<T>& geom, double d, std::set<V>* s) const {
 // _____________________________________________________________________________
 template <typename V, template <typename> class G, typename T>
 void Grid<V, G, T>::get(size_t x, size_t y, std::set<V>* s) const {
-  if (_hasValIdx) {
+  if (_hasValIdx || _removed.size() == 0) {
     s->insert(_grid[x][y].begin(), _grid[x][y].end());
   } else {
     // if we dont have a value index, we have a set of deleted nodes.

src/util/geo/PolyLine.h

@@ -17,7 +17,6 @@ namespace util {
 namespace geo {
 
 static const double MAX_EQ_DISTANCE = 15;
-static const double AVERAGING_STEP = 20;
 
 // legacy code, will be removed in the future
 
@@ -61,11 +60,11 @@ class PolyLine {
   PolyLine& operator>>(const Point<T>& p);
 
   void reverse();
-  PolyLine getReversed() const;
+  PolyLine reversed() const;
 
   void offsetPerp(double units);
 
-  PolyLine getPerpOffsetted(double units) const;
+  PolyLine offsetted(double units) const;
 
   const Line<T>& getLine() const;
 

src/util/geo/PolyLine.tpp

@@ -38,7 +38,7 @@ void PolyLine<T>::reverse() {
 
 // _____________________________________________________________________________
 template <typename T>
-PolyLine<T> PolyLine<T>::getReversed() const {
+PolyLine<T> PolyLine<T>::reversed() const {
   PolyLine ret = *this;
   ret.reverse();
   return ret;
@@ -52,7 +52,7 @@ const Line<T>& PolyLine<T>::getLine() const {
 
 // _____________________________________________________________________________
 template <typename T>
-PolyLine<T> PolyLine<T>::getPerpOffsetted(double units) const {
+PolyLine<T> PolyLine<T>::offsetted(double units) const {
   PolyLine p = *this;
   p.offsetPerp(units);
   return p;
@@ -191,6 +191,8 @@ PolyLine<T> PolyLine<T>::getSegment(const LinePoint<T>& start,
   // find a more performant way to clear the result of above
   ret.simplify(0);
 
+  assert(ret.getLine().size());
+
   return ret;
 }
 
@@ -475,7 +477,7 @@ SharedSegments<T> PolyLine<T>::getSharedSegments(const PolyLine<T>& pl,
    */
   double STEP_SIZE = 2;
   double MAX_SKIPS = 4;
-  double MIN_SEG_LENGTH = 1;  // dmax / 2;  // make this configurable!
+  double MIN_SEG_LENGTH = 0.1;  // dmax / 2;  // make this configurable!
 
   SharedSegments<T> ret;
 
@@ -499,17 +501,22 @@ SharedSegments<T> PolyLine<T>::getSharedSegments(const PolyLine<T>& pl,
 
     double totalDist = dist(s, e);
     while (curSegDist <= totalDist) {
-      const Point<T>& curPointer = interpolate(s, e, curSegDist);
+      const auto& curPointer = interpolate(s, e, curSegDist);
 
       if (pl.distTo(curPointer) <= dmax) {
         LinePoint<T> curCmpPointer = pl.projectOn(curPointer);
         LinePoint<T> curBackProjectedPointer = projectOn(curCmpPointer.p);
+
         skips = 0;
 
         if (in) {
           curEndCand = curBackProjectedPointer;
           curEndCandCmp = curCmpPointer;
 
+          if (curEndCand.totalPos < curStartCand.totalPos) {
+            curEndCand = curStartCand;
+          }
+
           single = false;
 
           comp = fabs(curStartCand.totalPos * length -

src/util/geo/QuadTree.h

@@ -0,0 +1,89 @@
+// Copyright 2020, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_QUADTREE_H_
+#define UTIL_GEO_QUADTREE_H_
+
+#include <map>
+#include <set>
+#include <vector>
+#include "util/geo/Geo.h"
+
+namespace util {
+namespace geo {
+
+template <typename V, typename T>
+struct QuadValue {
+  V val;           // the actual value of this entry
+  Point<T> point;  // the value's position
+
+  int64_t nextValue;  // index of the next quad value, -1 means no next value
+};
+
+template <typename T>
+struct QuadNode {
+  int64_t numEls;  // number of elements, -1 if this is not a leaf node
+  int64_t childs;  // for leafs, points to the first value contained. for
+                   // other nodes, points to the array block containing the
+                   // 4 childs
+  Box<T> bbox;
+};
+
+template <typename V, typename T>
+struct SplitFunc {
+  virtual ~SplitFunc() = default;
+  virtual bool operator()(const QuadNode<T>& nd,
+                       const QuadValue<V, T>& newVal) const = 0;
+};
+
+template <typename V, typename T>
+struct CapaSplitFunc : SplitFunc<V, T> {
+  CapaSplitFunc(size_t c) : _c(c) {}
+  virtual bool operator()(const QuadNode<T>& nd,
+                       const QuadValue<V, T>& newVal) const {
+    return static_cast<size_t>(nd.numEls) + 1 > _c;
+  }
+  size_t _c;
+};
+
+// QuadTree for point data (and only point data)
+template <typename V, typename T>
+class QuadTree {
+ public:
+  // initialization of a quad tree with maximum depth d and maximum node // capacity c
+  QuadTree(size_t d, size_t c, const Box<T>& bbox);
+
+  QuadTree(size_t d, const SplitFunc<V, T>& splitF, const Box<T>& bbox);
+
+  // insert into the tree
+  void insert(const V& val, const Point<T>& point);
+
+  // insert into a specific node
+  void insert(int64_t vid, int64_t nid, size_t d);
+
+  size_t size() const;
+
+  const std::vector<QuadNode<T>>& getNds() const;
+  const QuadNode<T>& getNd(size_t nid) const;
+
+ private:
+  size_t _maxDepth;
+  std::vector<QuadValue<V, T>> _vals;
+  std::vector<QuadNode<T>> _nds;
+
+  CapaSplitFunc<V, T> _capaFunc;
+
+  const SplitFunc<V, T>& _splFunc;
+
+
+  // split a node
+  void split(size_t nid, size_t d);
+};
+
+#include "util/geo/QuadTree.tpp"
+
+}  // namespace geo
+}  // namespace util
+
+#endif  // UTIL_GEO_QUADTREE_H_

src/util/geo/QuadTree.tpp

@@ -0,0 +1,107 @@
+// _____________________________________________________________________________
+template <typename V, typename T>
+QuadTree<V, T>::QuadTree(size_t d, size_t c, const Box<T>& bbox)
+    : _maxDepth(d), _capaFunc(c), _splFunc(_capaFunc) {
+  _nds.push_back(QuadNode<T>{0, 0, bbox});
+}
+
+// _____________________________________________________________________________
+template <typename V, typename T>
+QuadTree<V, T>::QuadTree(size_t d, const SplitFunc<V, T>& splitF,
+                         const Box<T>& bbox)
+    : _maxDepth(d), _capaFunc(0), _splFunc(splitF) {
+  _nds.push_back(QuadNode<T>{0, 0, bbox});
+}
+
+// _____________________________________________________________________________
+template <typename V, typename T>
+void QuadTree<V, T>::insert(const V& val, const Point<T>& pos) {
+  if (!intersects(pos, _nds[0].bbox)) return;
+  int64_t valId = _vals.size();
+  _vals.push_back(QuadValue<V, T>{val, pos, -1});
+  _vals[valId].nextValue = -1;
+  insert(valId, 0, 0);
+}
+
+// _____________________________________________________________________________
+template <typename V, typename T>
+void QuadTree<V, T>::insert(int64_t vid, int64_t nid, size_t d) {
+  if (!intersects(_vals[vid].point, _nds[nid].bbox)) return;
+
+  if (d < _maxDepth && _nds[nid].numEls > -1 &&
+      _splFunc(_nds[nid], _vals[vid])) {
+    split(nid, d);
+  }
+
+  if (_nds[nid].numEls == -1) {
+    // insert into fitting subtree
+    for (size_t i = 0; i < 4; i++) insert(vid, _nds[nid].childs + i, d + 1);
+  } else {
+    if (_nds[nid].numEls == 0) {
+      _nds[nid].childs = vid;
+    } else {
+      _vals[vid].nextValue = _nds[nid].childs;
+      _nds[nid].childs = vid;
+    }
+    _nds[nid].numEls++;
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, typename T>
+void QuadTree<V, T>::split(size_t nid, size_t d) {
+  const auto& box = _nds[nid].bbox;
+  T w = (box.getUpperRight().getX() - box.getLowerLeft().getX()) / T(2);
+
+  int64_t curEl = _nds[nid].numEls > 0 ? _nds[nid].childs : -1;
+
+  _nds[nid].numEls = -1;           // the node is now a leaf node
+  _nds[nid].childs = _nds.size();  // the nodes quadrant block starts here
+
+  // box at 0, 0
+  _nds.push_back(QuadNode<T>{
+      0, 0,
+      Box<T>(box.getLowerLeft(), Point<T>(box.getLowerLeft().getX() + w,
+                                          box.getLowerLeft().getY() + w))});
+  // box at 0, 1
+  _nds.push_back(QuadNode<T>{
+      0, 0,
+      Box<T>(Point<T>(box.getLowerLeft().getX() + w, box.getLowerLeft().getY()),
+             Point<T>(box.getUpperRight().getX(),
+                      box.getLowerLeft().getY() + w))});
+  // box at 1,0
+  _nds.push_back(QuadNode<T>{
+      0, 0,
+      Box<T>(Point<T>(box.getLowerLeft().getX(), box.getLowerLeft().getY() + w),
+             Point<T>(box.getLowerLeft().getX() + w,
+                      box.getUpperRight().getY()))});
+  // box at 1,1
+  _nds.push_back(QuadNode<T>{0, 0,
+                             Box<T>(Point<T>(box.getLowerLeft().getX() + w,
+                                             box.getLowerLeft().getY() + w),
+                                    box.getUpperRight())});
+
+  while (curEl > -1) {
+    _vals[curEl].nextValue = -1;
+    insert(curEl, nid, d + 1);
+    curEl = _vals[curEl].nextValue;
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, typename T>
+size_t QuadTree<V, T>::size() const {
+  return _vals.size();
+}
+
+// _____________________________________________________________________________
+template <typename V, typename T>
+const QuadNode<T>& QuadTree<V, T>::getNd(size_t nid) const {
+  return _nds[nid];
+}
+
+// _____________________________________________________________________________
+template <typename V, typename T>
+const std::vector<QuadNode<T>>& QuadTree<V, T>::getNds() const {
+  return _nds;
+}

src/util/geo/output/GeoGraphJsonOutput.h

@@ -18,13 +18,23 @@ namespace output {
 class GeoGraphJsonOutput {
  public:
   inline GeoGraphJsonOutput(){};
+
+  // print a graph to the provided path
   template <typename N, typename E>
   void print(const util::graph::Graph<N, E>& outG, std::ostream& str);
 
+  // print a graph to the provided path, but treat coordinates as Web Mercator coordinates and reproject to WGS84
+  template <typename N, typename E>
+  void printLatLng(const util::graph::Graph<N, E>& outG, std::ostream& str);
+
  private:
   template <typename T>
   Line<T> createLine(const util::geo::Point<T>& a,
                      const util::geo::Point<T>& b);
+
+  // print a graph to the provided path
+  template <typename N, typename E>
+  void printImpl(const util::graph::Graph<N, E>& outG, std::ostream& str, bool proj);
 };
 
 #include "util/geo/output/GeoGraphJsonOutput.tpp"

src/util/geo/output/GeoGraphJsonOutput.tpp

@@ -16,6 +16,20 @@ Line<T> GeoGraphJsonOutput::createLine(const util::geo::Point<T>& a,
 template <typename N, typename E>
 void GeoGraphJsonOutput::print(const util::graph::Graph<N, E>& outG,
                                std::ostream& str) {
+  printImpl(outG, str, false);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void GeoGraphJsonOutput::printLatLng(const util::graph::Graph<N, E>& outG,
+                               std::ostream& str) {
+  printImpl(outG, str, true);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void GeoGraphJsonOutput::printImpl(const util::graph::Graph<N, E>& outG,
+                               std::ostream& str, bool proj) {
   GeoJsonOutput _out(str);
 
   // first pass, nodes
@@ -30,7 +44,11 @@ void GeoGraphJsonOutput::print(const util::graph::Graph<N, E>& outG,
     auto addProps = n->pl().getAttrs();
     props.insert(addProps.begin(), addProps.end());
 
-    _out.print(*n->pl().getGeom(), props);
+    if (proj) {
+      _out.printLatLng(*n->pl().getGeom(), props);
+    } else {
+      _out.print(*n->pl().getGeom(), props);
+    }
   }
 
   // second pass, edges
@@ -50,11 +68,19 @@ void GeoGraphJsonOutput::print(const util::graph::Graph<N, E>& outG,
           auto a = *e->getFrom()->pl().getGeom();
           if (e->getTo()->pl().getGeom()) {
             auto b = *e->getTo()->pl().getGeom();
-            _out.print(createLine(a, b), props);
+            if (proj) {
+              _out.printLatLng(createLine(a, b), props);
+            } else {
+              _out.print(createLine(a, b), props);
+            }
           }
         }
       } else {
-        _out.print(*e->pl().getGeom(), props);
+        if (proj) {
+          _out.printLatLng(*e->pl().getGeom(), props);
+        } else {
+          _out.print(*e->pl().getGeom(), props);
+        }
       }
     }
   }

src/util/geo/output/GeoJsonOutput.h

@@ -5,9 +5,9 @@
 #ifndef UTIL_GEO_OUTPUT_GEOJSONOUTPUT_H_
 #define UTIL_GEO_OUTPUT_GEOJSONOUTPUT_H_
 
+#include <map>
 #include <ostream>
 #include <string>
-#include <map>
 #include "util/String.h"
 #include "util/geo/Geo.h"
 #include "util/json/Writer.h"
@@ -21,10 +21,19 @@ class GeoJsonOutput {
   GeoJsonOutput(std::ostream& str);
   GeoJsonOutput(std::ostream& str, json::Val attrs);
   ~GeoJsonOutput();
+
   template <typename T>
   void print(const Point<T>& p, json::Val attrs);
+
   template <typename T>
   void print(const Line<T>& l, json::Val attrs);
+
+  template <typename T>
+  void printLatLng(const Point<T>& p, json::Val attrs);
+
+  template <typename T>
+  void printLatLng(const Line<T>& l, json::Val attrs);
+
   void flush();
 
  private:
@@ -32,7 +41,6 @@ class GeoJsonOutput {
 };
 
 #include "util/geo/output/GeoJsonOutput.tpp"
-
 }
 }
 }

src/util/geo/output/GeoJsonOutput.tpp

@@ -46,3 +46,19 @@ void GeoJsonOutput::print(const Line<T>& line, json::Val attrs) {
   _wr.val(attrs);
   _wr.close();
 }
+
+// _____________________________________________________________________________
+template <typename T>
+void GeoJsonOutput::printLatLng(const Point<T>& p, json::Val attrs) {
+  auto projP = util::geo::webMercToLatLng<double>(p.getX(), p.getY());
+  print(projP, attrs);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void GeoJsonOutput::printLatLng(const Line<T>& line, json::Val attrs) {
+  Line<T> projL;
+  for (auto p : line) projL.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
+
+  print(projL, attrs);
+}

src/util/graph/Algorithm.h

@@ -7,8 +7,8 @@
 
 #include <stack>
 #include "util/graph/Edge.h"
-#include "util/graph/UndirGraph.h"
 #include "util/graph/Node.h"
+#include "util/graph/UndirGraph.h"
 
 namespace util {
 namespace graph {
@@ -21,12 +21,25 @@ using util::graph::Edge;
 class Algorithm {
  public:
   template <typename N, typename E>
+  struct EdgeCheckFunc {
+    virtual bool operator()(const Node<N, E>* frNd,
+                            const Edge<N, E>* edge) const {
+      UNUSED(frNd);
+      UNUSED(edge);
+      return true;
+    };
+  };
+
+  template <typename N, typename E>
   static std::vector<std::set<Node<N, E>*> > connectedComponents(
       const UndirGraph<N, E>& g);
+
+  template <typename N, typename E>
+  static std::vector<std::set<Node<N, E>*> > connectedComponents(
+      const UndirGraph<N, E>& g, const EdgeCheckFunc<N, E>& checkFunc);
 };
 
 #include "util/graph/Algorithm.tpp"
-
 }
 }
 

src/util/graph/Algorithm.tpp

@@ -1,11 +1,18 @@
 // Copyright 2017, University of Freiburg,
 // Chair of Algorithms and Data Structures.
 // Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
-
+//
 // _____________________________________________________________________________
 template <typename N, typename E>
-std::vector<std::set<Node<N, E>*> > Algorithm::connectedComponents(
+std::vector<std::set<Node<N, E>*>> Algorithm::connectedComponents(
     const UndirGraph<N, E>& g) {
+  return connectedComponents(g, EdgeCheckFunc<N, E>());
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+std::vector<std::set<Node<N, E>*>> Algorithm::connectedComponents(
+    const UndirGraph<N, E>& g, const EdgeCheckFunc<N, E>& checkFunc) {
   std::vector<std::set<Node<N, E>*>> ret;
   std::set<Node<N, E>*> visited;
 
@@ -22,6 +29,7 @@ std::vector<std::set<Node<N, E>*> > Algorithm::connectedComponents(
         visited.insert(cur);
 
         for (auto* e : cur->getAdjList()) {
+          if (!checkFunc(cur, e)) continue;
           if (!visited.count(e->getOtherNd(cur))) q.push(e->getOtherNd(cur));
         }
       }

src/util/graph/BiDijkstra.cpp

@@ -0,0 +1,7 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include "util/graph/BiDijkstra.h"
+
+size_t util::graph::BiDijkstra::ITERS = 0;

src/util/graph/BiDijkstra.h

@@ -0,0 +1,129 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_BIDIJKSTRA_H_
+#define UTIL_GRAPH_BIDIJKSTRA_H_
+
+#include <limits>
+#include <list>
+#include <queue>
+#include <set>
+#include <algorithm>
+#include <unordered_map>
+#include "util/graph/Edge.h"
+#include "util/graph/Graph.h"
+#include "util/graph/Node.h"
+#include "util/graph/ShortestPath.h"
+
+namespace util {
+namespace graph {
+
+using util::graph::Edge;
+using util::graph::Graph;
+using util::graph::Node;
+
+// bidirectional dijkstras algorithm for util graph
+class BiDijkstra : public ShortestPath<BiDijkstra> {
+ public:
+  template <typename N, typename E, typename C>
+  struct RouteNode {
+    RouteNode() : n(0), parent(0), d(), h() {}
+    RouteNode(Node<N, E>* n) : n(n), parent(0), d(), h() {}
+    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d)
+        : n(n), parent(parent), d(d), h() {}
+    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d, C h)
+        : n(n), parent(parent), d(d), h(h) {}
+
+    Node<N, E>* n;
+    Node<N, E>* parent;
+
+    // the cost so far
+    C d;
+
+    // the heuristical remaining cost + the cost so far
+    C h;
+
+    bool operator<(const RouteNode<N, E, C>& p) const { return h > p.h; }
+  };
+
+  template <typename N, typename E, typename C>
+  using Settled = std::unordered_map<Node<N, E>*, RouteNode<N, E, C> >;
+
+  template <typename N, typename E, typename C>
+  using PQ = std::priority_queue<RouteNode<N, E, C> >;
+
+  template <typename N, typename E, typename C>
+  struct CostFunc : public util::graph::CostFunc<N, E, C> {
+    virtual ~CostFunc() = default; C operator()(const Edge<N, E>* from, const Node<N, E>* n,
+                 const Edge<N, E>* to) const {
+      UNUSED(from);
+      UNUSED(n);
+      UNUSED(to);
+      return C();
+    };
+  };
+
+  template <typename N, typename E, typename C>
+  struct HeurFunc : public util::graph::HeurFunc<N, E, C> {
+    virtual ~HeurFunc() = default;
+    C operator()(const Edge<N, E>* from,
+                 const std::set<Edge<N, E>*>& to) const {
+      UNUSED(from);
+      UNUSED(to);
+      return C();
+    };
+  };
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPathImpl(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const util::graph::CostFunc<N, E, C>& costFunc,
+      const util::graph::HeurFunc<N, E, C>&,
+      std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
+      std::unordered_map<Node<N, E>*, NList<N, E>*> resNode);
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(const std::set<Node<N, E>*> from,
+                            const std::set<Node<N, E>*>& to,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static void relax(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
+                    const util::graph::CostFunc<N, E, C>& costFunc,
+                    const util::graph::HeurFunc<N, E, C>& heurFunc,
+                    PQ<N, E, C>& pq);
+
+  template <typename N, typename E, typename C>
+  static C relaxFwd(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
+                    const util::graph::CostFunc<N, E, C>& costFunc,
+                    const util::graph::HeurFunc<N, E, C>& heurFunc,
+                    PQ<N, E, C>& pq, const Settled<N, E, C>& settledBwd);
+
+  template <typename N, typename E, typename C>
+  static C relaxBwd(const std::set<Node<N, E>*>& froms, RouteNode<N, E, C>& cur,
+                    const util::graph::CostFunc<N, E, C>& costFunc,
+                    const util::graph::HeurFunc<N, E, C>& heurFunc,
+                    PQ<N, E, C>& pq, const Settled<N, E, C>& settledFwd);
+
+  template <typename N, typename E, typename C>
+  static void buildPath(Node<N, E>* curN, Settled<N, E, C>& settledFwd,
+                        Settled<N, E, C>& settledBwd, NList<N, E>* resNodes,
+                        EList<N, E>* resEdges);
+
+  static size_t ITERS;
+};
+
+#include "util/graph/BiDijkstra.tpp"
+}  // namespace graph
+}  // namespace util
+
+#endif  // UTIL_GRAPH_BIDIJKSTRA_H_

src/util/graph/BiDijkstra.tpp

@@ -0,0 +1,283 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C BiDijkstra::shortestPathImpl(Node<N, E>* from,
+                               const std::set<Node<N, E>*>& to,
+                               const util::graph::CostFunc<N, E, C>& costFunc,
+                               const util::graph::HeurFunc<N, E, C>& heurFunc,
+                               EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  if (from->getOutDeg() == 0) return costFunc.inf();
+
+  std::set<Node<N, E>*> froms;
+  froms.insert(from);
+
+  return shortestPathImpl(froms, to, costFunc, heurFunc, resEdges, resNodes);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C BiDijkstra::shortestPathImpl(const std::set<Node<N, E>*> from,
+                               const std::set<Node<N, E>*>& to,
+                               const util::graph::CostFunc<N, E, C>& costFunc,
+                               const util::graph::HeurFunc<N, E, C>& heurFunc,
+                               EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  Settled<N, E, C> settledFwd, settledBwd;
+  PQ<N, E, C> pqFwd, pqBwd;
+  bool found = false;
+
+  // starter for forward search
+  for (auto n : from) pqFwd.emplace(n);
+
+  auto l = costFunc.inf();
+
+  // starter for backward search
+  for (auto n : to) pqBwd.emplace(n);
+
+  RouteNode<N, E, C> cur;
+
+  while (!pqFwd.empty() && !pqBwd.empty()) {
+    if (costFunc.inf() <= pqFwd.top().h && costFunc.inf() <= pqBwd.top().h)
+      return costFunc.inf();
+
+    if (pqFwd.top() < pqBwd.top()) {
+      auto se = settledBwd.find(pqBwd.top().n);
+      if (se != settledBwd.end()) {
+        // to allow non-consistent heuristics
+        if (se->second.d <= pqBwd.top().d) {
+          pqBwd.pop();
+          continue;
+        }
+      }
+    } else {
+      auto se = settledFwd.find(pqFwd.top().n);
+      if (se != settledFwd.end()) {
+        // to allow non-consistent heuristics
+        if (se->second.d <= pqFwd.top().d) {
+          pqFwd.pop();
+          continue;
+        }
+      }
+    }
+
+    BiDijkstra::ITERS++;
+
+    if (pqFwd.top() < pqBwd.top()) {
+      cur = pqBwd.top();
+      pqBwd.pop();
+      settledBwd[cur.n] = cur;
+      if (settledFwd.find(cur.n) != settledFwd.end()) {
+        auto newL = cur.d + settledFwd.find(cur.n)->second.d;
+
+        if (!(newL > l)) {
+          l = newL;
+          found = true;
+          break;
+        }
+      }
+      C bestCost = relaxBwd(from, cur, costFunc, heurFunc, pqBwd, settledFwd);
+      if (bestCost < l) l = bestCost;
+    } else {
+      cur = pqFwd.top();
+      pqFwd.pop();
+      settledFwd[cur.n] = cur;
+      if (settledBwd.find(cur.n) != settledBwd.end()) {
+        auto newL = cur.d + settledBwd.find(cur.n)->second.d;
+
+        if (!(newL > l)) {
+          l = newL;
+          found = true;
+          break;
+        }
+      }
+      C bestCost = relaxFwd(cur, to, costFunc, heurFunc, pqFwd, settledBwd);
+      if (bestCost < l) l = bestCost;
+    }
+  }
+
+  if (!found) return costFunc.inf();
+
+  buildPath(cur.n, settledFwd, settledBwd, resNodes, resEdges);
+
+  return l;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+std::unordered_map<Node<N, E>*, C> BiDijkstra::shortestPathImpl(
+    Node<N, E>* from, const std::set<Node<N, E>*>& to,
+    const util::graph::CostFunc<N, E, C>& costFunc,
+    const util::graph::HeurFunc<N, E, C>& heurFunc,
+    std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
+    std::unordered_map<Node<N, E>*, NList<N, E>*> resNodes) {
+  assert(false);
+  // std::unordered_map<Node<N, E>*, C> costs;
+  // if (to.size() == 0) return costs;
+  // // init costs with inf
+  // for (auto n : to) costs[n] = costFunc.inf();
+
+  // if (from->getOutDeg() == 0) return costs;
+  // Settled<N, E, C> settled;
+  // PQ<N, E, C> pq;
+
+  // size_t found = 0;
+
+  // pq.emplace(from);
+  // RouteNode<N, E, C> cur;
+
+  // while (!pq.empty()) {
+  // if (costFunc.inf() <= pq.top().h) return costs;
+  // if (settled.find(pq.top().n) != settled.end()) {
+  // pq.pop();
+  // continue;
+  // }
+  // BiDijkstra::ITERS++;
+
+  // cur = pq.top();
+  // pq.pop();
+
+  // settled[cur.n] = cur;
+
+  // if (to.find(cur.n) != to.end()) {
+  // found++;
+  // }
+
+  // if (found == to.size()) break;
+
+  // relax(cur, to, costFunc, heurFunc, pq);
+  // }
+
+  // for (auto nto : to) {
+  // if (!settled.count(nto)) continue;
+  // Node<N, E>* curN = nto;
+  // costs[nto] = settled[curN].d;
+
+  // buildPath(nto, settled, resNodes[nto], resEdges[nto]);
+  // }
+
+  // return costs;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+void BiDijkstra::relax(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
+                       const util::graph::CostFunc<N, E, C>& costFunc,
+                       const util::graph::HeurFunc<N, E, C>& heurFunc,
+                       PQ<N, E, C>& pq) {
+  for (auto edge : cur.n->getAdjListOut()) {
+    C newC = costFunc(cur.n, edge, edge->getOtherNd(cur.n));
+    newC = cur.d + newC;
+    if (costFunc.inf() <= newC) continue;
+
+    // addition done here to avoid it in the PQ
+    const C& newH = newC + heurFunc(edge->getOtherNd(cur.n), to);
+
+    pq.emplace(edge->getOtherNd(cur.n), cur.n, newC, newH);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C BiDijkstra::relaxFwd(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
+                       const util::graph::CostFunc<N, E, C>& costFunc,
+                       const util::graph::HeurFunc<N, E, C>& heurFunc,
+                       PQ<N, E, C>& pq, const Settled<N, E, C>& settledBwd) {
+  C ret = costFunc.inf();
+  for (auto edge : cur.n->getAdjListOut()) {
+    C newC = costFunc(cur.n, edge, edge->getOtherNd(cur.n));
+    newC = cur.d + newC;
+    if (costFunc.inf() <= newC) continue;
+
+    // addition done here to avoid it in the PQ
+    // const C& newH = newC + heurFunc(froms, edge->getOtherNd(cur.n));
+
+    // TODO:
+    const C& newH = newC + 0;
+
+    // update new best found cost
+    if (settledBwd.find(edge->getOtherNd(cur.n)) != settledBwd.end()) {
+      C bwdCost = settledBwd.find(edge->getOtherNd(cur.n))->second.d + newC;
+      if (bwdCost < ret) ret = bwdCost;
+    }
+
+    pq.emplace(edge->getOtherNd(cur.n), cur.n, newC, newH);
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C BiDijkstra::relaxBwd(const std::set<Node<N, E>*>& froms,
+                       RouteNode<N, E, C>& cur,
+                       const util::graph::CostFunc<N, E, C>& costFunc,
+                       const util::graph::HeurFunc<N, E, C>& heurFunc,
+                       PQ<N, E, C>& pq, const Settled<N, E, C>& settledFwd) {
+  C ret = costFunc.inf();
+  for (auto edge : cur.n->getAdjListIn()) {
+    C newC = costFunc(edge->getOtherNd(cur.n), edge, cur.n);
+    newC = cur.d + newC;
+    if (costFunc.inf() <= newC) continue;
+
+    // addition done here to avoid it in the PQ
+    // const C& newH = newC + heurFunc(froms, edge->getOtherNd(cur.n));
+
+    // TODO:
+    const C& newH = newC + 0;
+
+    // update new best found cost
+    if (settledFwd.find(edge->getOtherNd(cur.n)) != settledFwd.end()) {
+      C fwdCost = settledFwd.find(edge->getOtherNd(cur.n))->second.d + newC;
+      if (fwdCost < ret) ret = fwdCost;
+    }
+
+    pq.emplace(edge->getOtherNd(cur.n), cur.n, newC, newH);
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+void BiDijkstra::buildPath(Node<N, E>* curN, Settled<N, E, C>& settledFwd,
+                           Settled<N, E, C>& settledBwd, NList<N, E>* resNodes,
+                           EList<N, E>* resEdges) {
+  Node<N, E>* curNFwd = curN;
+  Node<N, E>* curNBwd = curN;
+
+  // the forward part
+  while (resNodes || resEdges) {
+    const RouteNode<N, E, C>& curNode = settledFwd[curNFwd];
+    if (resNodes) resNodes->push_back(curNode.n);
+    if (!curNode.parent) break;
+
+    if (resEdges) {
+      for (auto e : curNode.n->getAdjListIn()) {
+        if (e->getOtherNd(curNode.n) == curNode.parent) resEdges->push_back(e);
+      }
+    }
+    curNFwd = curNode.parent;
+  }
+
+  if (resNodes) std::reverse(resNodes->begin(), resNodes->end());
+  if (resEdges) std::reverse(resEdges->begin(), resEdges->end());
+
+  // the backward part
+  while (resNodes || resEdges) {
+    const RouteNode<N, E, C>& curNode = settledBwd[curNBwd];
+    if (resNodes && curNode.n != curN) resNodes->push_back(curNode.n);
+    if (!curNode.parent) break;
+
+    if (resEdges) {
+      for (auto e : curNode.n->getAdjListOut()) {
+        if (e->getOtherNd(curNode.n) == curNode.parent) resEdges->push_back(e);
+      }
+    }
+    curNBwd = curNode.parent;
+  }
+
+  if (resNodes) std::reverse(resNodes->begin(), resNodes->end());
+  if (resEdges) std::reverse(resEdges->begin(), resEdges->end());
+}

src/util/graph/Dijkstra.cpp

@@ -5,3 +5,4 @@
 #include "util/graph/Dijkstra.h"
 
 size_t util::graph::Dijkstra::ITERS = 0;
+size_t util::graph::Dijkstra::DBL_VISITS = 0;

src/util/graph/Dijkstra.h

@@ -9,7 +9,6 @@
 #include <list>
 #include <queue>
 #include <set>
-#include <set>
 #include <unordered_map>
 #include "util/graph/Edge.h"
 #include "util/graph/Graph.h"
@@ -19,33 +18,32 @@
 namespace util {
 namespace graph {
 
+using util::graph::Edge;
 using util::graph::Graph;
 using util::graph::Node;
-using util::graph::Edge;
 
 // dijkstras algorithm for util graph
 class Dijkstra : public ShortestPath<Dijkstra> {
  public:
   template <typename N, typename E, typename C>
   struct RouteNode {
-    RouteNode() : n(0), parent(0), d(), h(), e(0) {}
-    RouteNode(Node<N, E>* n) : n(n), parent(0), d(), h(), e(0) {}
-    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d, Edge<N, E>* e)
-        : n(n), parent(parent), d(d), h(), e(e) {}
-    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d, C h, Edge<N, E>* e)
-        : n(n), parent(parent), d(d), h(h), e(e) {}
+    RouteNode() : n(0), parent(0), d(), h() {}
+    RouteNode(Node<N, E>* n) : n(n), parent(0), d(), h() {}
+    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d)
+        : n(n), parent(parent), d(d), h() {}
+    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d, C h)
+        : n(n), parent(parent), d(d), h(h) {}
 
     Node<N, E>* n;
     Node<N, E>* parent;
 
+    // the cost so far
     C d;
-    C h;
 
-    Edge<N, E>* e;
+    // the heuristical remaining cost + the cost so far
+    C h;
 
-    bool operator<(const RouteNode<N, E, C>& p) const {
-      return h > p.h || (h == p.h && d > p.d);
-    }
+    bool operator<(const RouteNode<N, E, C>& p) const { return h > p.h; }
   };
 
   template <typename N, typename E, typename C>
@@ -55,7 +53,8 @@ class Dijkstra : public ShortestPath<Dijkstra> {
   using PQ = std::priority_queue<RouteNode<N, E, C> >;
 
   template <typename N, typename E, typename C>
-  struct CostFunc : public ShortestPath::CostFunc<N, E, C> {
+  struct CostFunc : public util::graph::CostFunc<N, E, C> {
+    virtual ~CostFunc() = default;
     C operator()(const Edge<N, E>* from, const Node<N, E>* n,
                  const Edge<N, E>* to) const {
       UNUSED(from);
@@ -66,7 +65,8 @@ class Dijkstra : public ShortestPath<Dijkstra> {
   };
 
   template <typename N, typename E, typename C>
-  struct HeurFunc : public ShortestPath::HeurFunc<N, E, C> {
+  struct HeurFunc : public util::graph::HeurFunc<N, E, C> {
+    virtual ~HeurFunc() = default;
     C operator()(const Edge<N, E>* from,
                  const std::set<Edge<N, E>*>& to) const {
       UNUSED(from);
@@ -78,36 +78,40 @@ class Dijkstra : public ShortestPath<Dijkstra> {
   template <typename N, typename E, typename C>
   static std::unordered_map<Node<N, E>*, C> shortestPathImpl(
       Node<N, E>* from, const std::set<Node<N, E>*>& to,
-      const ShortestPath::CostFunc<N, E, C>& costFunc, const ShortestPath::HeurFunc<N, E, C>&,
+      const util::graph::CostFunc<N, E, C>& costFunc,
+      const util::graph::HeurFunc<N, E, C>&,
       std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
       std::unordered_map<Node<N, E>*, NList<N, E>*> resNode);
 
   template <typename N, typename E, typename C>
-  static C shortestPathImpl(const std::set<Node<N, E>*> from, const std::set<Node<N, E>*>& to,
-                            const ShortestPath::CostFunc<N, E, C>& costFunc,
-                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+  static C shortestPathImpl(const std::set<Node<N, E>*> from,
+                            const std::set<Node<N, E>*>& to,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
                             EList<N, E>* resEdges, NList<N, E>* resNodes);
 
   template <typename N, typename E, typename C>
   static C shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
-                            const ShortestPath::CostFunc<N, E, C>& costFunc,
-                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
                             EList<N, E>* resEdges, NList<N, E>* resNodes);
 
   template <typename N, typename E, typename C>
   static void relax(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
-                    const ShortestPath::CostFunc<N, E, C>& costFunc,
-                    const ShortestPath::HeurFunc<N, E, C>& heurFunc, PQ<N, E, C>& pq);
+                    const util::graph::CostFunc<N, E, C>& costFunc,
+                    const util::graph::HeurFunc<N, E, C>& heurFunc,
+                    PQ<N, E, C>& pq);
 
   template <typename N, typename E, typename C>
   static void buildPath(Node<N, E>* curN, Settled<N, E, C>& settled,
                         NList<N, E>* resNodes, EList<N, E>* resEdges);
 
   static size_t ITERS;
+  static size_t DBL_VISITS;
 };
 
 #include "util/graph/Dijkstra.tpp"
-}
-}
+}  // namespace graph
+}  // namespace util
 
 #endif  // UTIL_GRAPH_DIJKSTRA_H_

src/util/graph/Dijkstra.tpp

@@ -5,8 +5,8 @@
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
 C Dijkstra::shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
-                             const ShortestPath::CostFunc<N, E, C>& costFunc,
-                             const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                             const util::graph::CostFunc<N, E, C>& costFunc,
+                             const util::graph::HeurFunc<N, E, C>& heurFunc,
                              EList<N, E>* resEdges, NList<N, E>* resNodes) {
   if (from->getOutDeg() == 0) return costFunc.inf();
 
@@ -18,12 +18,12 @@ C Dijkstra::shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
   RouteNode<N, E, C> cur;
 
   while (!pq.empty()) {
-    Dijkstra::ITERS++;
-
+    if (costFunc.inf() <= pq.top().h) return costFunc.inf();
     if (settled.find(pq.top().n) != settled.end()) {
       pq.pop();
       continue;
     }
+    Dijkstra::ITERS++;
 
     cur = pq.top();
     pq.pop();
@@ -49,8 +49,8 @@ C Dijkstra::shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
 template <typename N, typename E, typename C>
 C Dijkstra::shortestPathImpl(const std::set<Node<N, E>*> from,
                              const std::set<Node<N, E>*>& to,
-                             const ShortestPath::CostFunc<N, E, C>& costFunc,
-                             const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                             const util::graph::CostFunc<N, E, C>& costFunc,
+                             const util::graph::HeurFunc<N, E, C>& heurFunc,
                              EList<N, E>* resEdges, NList<N, E>* resNodes) {
   Settled<N, E, C> settled;
   PQ<N, E, C> pq;
@@ -61,12 +61,17 @@ C Dijkstra::shortestPathImpl(const std::set<Node<N, E>*> from,
   RouteNode<N, E, C> cur;
 
   while (!pq.empty()) {
-    Dijkstra::ITERS++;
-
-    if (settled.find(pq.top().n) != settled.end()) {
-      pq.pop();
-      continue;
+    if (costFunc.inf() <= pq.top().h) return costFunc.inf();
+    auto se = settled.find(pq.top().n);
+    if (se != settled.end()) {
+      // to allow non-consistent heuristics
+      if (se->second.d <= pq.top().d) {
+        pq.pop();
+        continue;
+      }
+      Dijkstra::DBL_VISITS++;
     }
+    Dijkstra::ITERS++;
 
     cur = pq.top();
     pq.pop();
@@ -92,8 +97,8 @@ C Dijkstra::shortestPathImpl(const std::set<Node<N, E>*> from,
 template <typename N, typename E, typename C>
 std::unordered_map<Node<N, E>*, C> Dijkstra::shortestPathImpl(
     Node<N, E>* from, const std::set<Node<N, E>*>& to,
-    const ShortestPath::CostFunc<N, E, C>& costFunc,
-    const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+    const util::graph::CostFunc<N, E, C>& costFunc,
+    const util::graph::HeurFunc<N, E, C>& heurFunc,
     std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
     std::unordered_map<Node<N, E>*, NList<N, E>*> resNodes) {
   std::unordered_map<Node<N, E>*, C> costs;
@@ -112,12 +117,16 @@ std::unordered_map<Node<N, E>*, C> Dijkstra::shortestPathImpl(
   RouteNode<N, E, C> cur;
 
   while (!pq.empty()) {
-    Dijkstra::ITERS++;
-
-    if (settled.find(pq.top().n) != settled.end()) {
-      pq.pop();
-      continue;
+    if (costFunc.inf() <= pq.top().h) return costs;
+    auto se = settled.find(pq.top().n);
+    if (se != settled.end()) {
+      // to allow non-consistent heuristics
+      if (se->second.d <= pq.top().d) {
+        pq.pop();
+        continue;
+      }
     }
+    Dijkstra::ITERS++;
 
     cur = pq.top();
     pq.pop();
@@ -147,29 +156,35 @@ std::unordered_map<Node<N, E>*, C> Dijkstra::shortestPathImpl(
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
 void Dijkstra::relax(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
-                     const ShortestPath::CostFunc<N, E, C>& costFunc,
-                     const ShortestPath::HeurFunc<N, E, C>& heurFunc, PQ<N, E, C>& pq) {
+                     const util::graph::CostFunc<N, E, C>& costFunc,
+                     const util::graph::HeurFunc<N, E, C>& heurFunc,
+                     PQ<N, E, C>& pq) {
   for (auto edge : cur.n->getAdjListOut()) {
     C newC = costFunc(cur.n, edge, edge->getOtherNd(cur.n));
     newC = cur.d + newC;
     if (costFunc.inf() <= newC) continue;
 
+    // addition done here to avoid it in the PQ
     const C& newH = newC + heurFunc(edge->getOtherNd(cur.n), to);
 
-    pq.emplace(edge->getOtherNd(cur.n), cur.n, newC, newH, &(*edge));
+    pq.emplace(edge->getOtherNd(cur.n), cur.n, newC, newH);
   }
 }
 
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
-void Dijkstra::buildPath(Node<N, E>* curN,
-                         Settled<N, E, C>& settled, NList<N, E>* resNodes,
-                         EList<N, E>* resEdges) {
-  while (true) {
+void Dijkstra::buildPath(Node<N, E>* curN, Settled<N, E, C>& settled,
+                         NList<N, E>* resNodes, EList<N, E>* resEdges) {
+  while (resNodes || resEdges) {
     const RouteNode<N, E, C>& curNode = settled[curN];
     if (resNodes) resNodes->push_back(curNode.n);
     if (!curNode.parent) break;
-    if (resEdges) resEdges->push_back(curNode.e);
+
+    if (resEdges) {
+      for (auto e : curNode.n->getAdjListIn()) {
+        if (e->getOtherNd(curNode.n) == curNode.parent) resEdges->push_back(e);
+      }
+    }
     curN = curNode.parent;
   }
 }

src/util/graph/DirGraph.h

@@ -21,8 +21,6 @@ using UndirEdge = Edge<N, E>;
 template <typename N, typename E>
 class DirGraph : public Graph<N, E> {
  public:
-  explicit DirGraph();
-
   using Graph<N, E>::addEdg;
 
   Node<N, E>* addNd();

src/util/graph/DirGraph.tpp

@@ -4,10 +4,6 @@
 
 // _____________________________________________________________________________
 template <typename N, typename E>
-DirGraph<N, E>::DirGraph() {}
-
-// _____________________________________________________________________________
-template <typename N, typename E>
 Node<N, E>* DirGraph<N, E>::addNd(const N& pl) {
   return addNd(new DirNode<N, E>(pl));
 }

src/util/graph/EDijkstra.h

@@ -37,18 +37,21 @@ class EDijkstra : public ShortestPath<EDijkstra> {
     Edge<N, E>* e;
     Edge<N, E>* parent;
 
+    // the cost so far
     C d;
+
+    // the heuristical remaining cost + the cost so far
     C h;
 
     Node<N, E>* n;
 
     bool operator<(const RouteEdge<N, E, C>& p) const {
-      return h > p.h || (h == p.h && d > p.d);
+      return h > p.h;
     }
   };
 
   template <typename N, typename E, typename C>
-  struct CostFunc : public ShortestPath::CostFunc<N, E, C> {
+  struct CostFunc : public util::graph::CostFunc<N, E, C> {
     C operator()(const Node<N, E>* from, const Edge<N, E>* e,
                  const Node<N, E>* to) const {
       UNUSED(from);
@@ -59,7 +62,7 @@ class EDijkstra : public ShortestPath<EDijkstra> {
   };
 
   template <typename N, typename E, typename C>
-  struct HeurFunc : public ShortestPath::HeurFunc<N, E, C> {
+  struct HeurFunc : public util::graph::HeurFunc<N, E, C> {
     C operator()(const Node<N, E>* from,
                  const std::set<Node<N, E>*>& to) const {
       UNUSED(from);
@@ -77,39 +80,39 @@ class EDijkstra : public ShortestPath<EDijkstra> {
   template <typename N, typename E, typename C>
   static C shortestPathImpl(const std::set<Edge<N, E>*> from,
                             const std::set<Edge<N, E>*>& to,
-                            const ShortestPath::CostFunc<N, E, C>& costFunc,
-                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
                             EList<N, E>* resEdges, NList<N, E>* resNodes);
 
   template <typename N, typename E, typename C>
   static C shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
-                            const ShortestPath::CostFunc<N, E, C>& costFunc,
-                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
                             EList<N, E>* resEdges, NList<N, E>* resNodes);
 
   template <typename N, typename E, typename C>
   static C shortestPathImpl(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
-                            const ShortestPath::CostFunc<N, E, C>& costFunc,
-                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
                             EList<N, E>* resEdges, NList<N, E>* resNodes);
 
   template <typename N, typename E, typename C>
   static C shortestPathImpl(const std::set<Edge<N, E>*>& from,
                             const std::set<Node<N, E>*>& to,
-                            const ShortestPath::CostFunc<N, E, C>& costFunc,
-                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            const util::graph::CostFunc<N, E, C>& costFunc,
+                            const util::graph::HeurFunc<N, E, C>& heurFunc,
                             EList<N, E>* resEdges, NList<N, E>* resNodes);
 
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPathImpl(
       const std::set<Edge<N, E>*>& from,
-      const ShortestPath::CostFunc<N, E, C>& costFunc, bool rev);
+      const util::graph::CostFunc<N, E, C>& costFunc, bool rev);
 
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPathImpl(
       Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
-      const ShortestPath::CostFunc<N, E, C>& costFunc,
-      const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+      const util::graph::CostFunc<N, E, C>& costFunc,
+      const util::graph::HeurFunc<N, E, C>& heurFunc,
       std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
       std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes);
 
@@ -120,13 +123,13 @@ class EDijkstra : public ShortestPath<EDijkstra> {
   template <typename N, typename E, typename C>
   static inline void relax(RouteEdge<N, E, C>& cur,
                            const std::set<Edge<N, E>*>& to,
-                           const ShortestPath::CostFunc<N, E, C>& costFunc,
-                           const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                           const util::graph::CostFunc<N, E, C>& costFunc,
+                           const util::graph::HeurFunc<N, E, C>& heurFunc,
                            PQ<N, E, C>& pq);
 
   template <typename N, typename E, typename C>
   static void relaxInv(RouteEdge<N, E, C>& cur,
-                      const ShortestPath::CostFunc<N, E, C>& costFunc,
+                      const util::graph::CostFunc<N, E, C>& costFunc,
                       PQ<N, E, C>& pq);
 
   static size_t ITERS;

src/util/graph/EDijkstra.tpp

@@ -5,8 +5,8 @@
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
 C EDijkstra::shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
-                              const ShortestPath::CostFunc<N, E, C>& costFunc,
-                              const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                              const util::graph::CostFunc<N, E, C>& costFunc,
+                              const util::graph::HeurFunc<N, E, C>& heurFunc,
                               EList<N, E>* resEdges, NList<N, E>* resNodes) {
   std::set<Edge<N, E>*> frEs;
   std::set<Edge<N, E>*> toEs;
@@ -28,8 +28,8 @@ C EDijkstra::shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
 C EDijkstra::shortestPathImpl(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
-                              const ShortestPath::CostFunc<N, E, C>& costFunc,
-                              const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                              const util::graph::CostFunc<N, E, C>& costFunc,
+                              const util::graph::HeurFunc<N, E, C>& heurFunc,
                               EList<N, E>* resEdges, NList<N, E>* resNodes) {
   std::set<Edge<N, E>*> frEs;
   std::set<Edge<N, E>*> toEs;
@@ -49,8 +49,8 @@ C EDijkstra::shortestPathImpl(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
 template <typename N, typename E, typename C>
 C EDijkstra::shortestPathImpl(const std::set<Edge<N, E>*> from,
                               const std::set<Edge<N, E>*>& to,
-                              const ShortestPath::CostFunc<N, E, C>& costFunc,
-                              const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                              const util::graph::CostFunc<N, E, C>& costFunc,
+                              const util::graph::HeurFunc<N, E, C>& heurFunc,
                               EList<N, E>* resEdges, NList<N, E>* resNodes) {
   if (from.size() == 0 || to.size() == 0) return costFunc.inf();
 
@@ -69,13 +69,18 @@ C EDijkstra::shortestPathImpl(const std::set<Edge<N, E>*> from,
   RouteEdge<N, E, C> cur;
 
   while (!pq.empty()) {
-    EDijkstra::ITERS++;
-
-    if (settled.find(pq.top().e) != settled.end()) {
-      pq.pop();
-      continue;
+    if (costFunc.inf() <= pq.top().h) return costFunc.inf();
+    auto se = settled.find(pq.top().e);
+    if (se != settled.end()) {
+      // to allow non-consistent heuristics
+      if (se->second.d <= pq.top().d) {
+        pq.pop();
+        continue;
+      }
     }
 
+    EDijkstra::ITERS++;
+
     cur = pq.top();
     pq.pop();
 
@@ -99,7 +104,7 @@ C EDijkstra::shortestPathImpl(const std::set<Edge<N, E>*> from,
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
 std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
-    const std::set<Edge<N, E>*>& from, const ShortestPath::CostFunc<N, E, C>& costFunc,
+    const std::set<Edge<N, E>*>& from, const util::graph::CostFunc<N, E, C>& costFunc,
     bool rev) {
   std::unordered_map<Edge<N, E>*, C> costs;
 
@@ -115,13 +120,17 @@ std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
   RouteEdge<N, E, C> cur;
 
   while (!pq.empty()) {
-    EDijkstra::ITERS++;
-
-    if (settled.find(pq.top().e) != settled.end()) {
-      pq.pop();
-      continue;
+    auto se = settled.find(pq.top().e);
+    if (se != settled.end()) {
+      // to allow non-consistent heuristics
+      if (se->second.d <= pq.top().d) {
+        pq.pop();
+        continue;
+      }
     }
 
+    EDijkstra::ITERS++;
+
     cur = pq.top();
     pq.pop();
 
@@ -143,8 +152,8 @@ std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
 template <typename N, typename E, typename C>
 std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
     Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
-    const ShortestPath::CostFunc<N, E, C>& costFunc,
-    const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+    const util::graph::CostFunc<N, E, C>& costFunc,
+    const util::graph::HeurFunc<N, E, C>& heurFunc,
     std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
     std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes) {
   std::unordered_map<Edge<N, E>*, C> costs;
@@ -165,13 +174,18 @@ std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
   RouteEdge<N, E, C> cur;
 
   while (!pq.empty()) {
-    EDijkstra::ITERS++;
-
-    if (settled.find(pq.top().e) != settled.end()) {
-      pq.pop();
-      continue;
+    if (costFunc.inf() <= pq.top().h) return costs;
+    auto se = settled.find(pq.top().e);
+    if (se != settled.end()) {
+      // to allow non-consistent heuristics
+      if (se->second.d <= pq.top().d) {
+        pq.pop();
+        continue;
+      }
     }
 
+    EDijkstra::ITERS++;
+
     cur = pq.top();
     pq.pop();
 
@@ -194,7 +208,7 @@ std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
 void EDijkstra::relaxInv(RouteEdge<N, E, C>& cur,
-                         const ShortestPath::CostFunc<N, E, C>& costFunc,
+                         const util::graph::CostFunc<N, E, C>& costFunc,
                          PQ<N, E, C>& pq) {
 
   // handling undirected graph makes no sense here
@@ -212,8 +226,8 @@ void EDijkstra::relaxInv(RouteEdge<N, E, C>& cur,
 // _____________________________________________________________________________
 template <typename N, typename E, typename C>
 void EDijkstra::relax(RouteEdge<N, E, C>& cur, const std::set<Edge<N, E>*>& to,
-                      const ShortestPath::CostFunc<N, E, C>& costFunc,
-                      const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                      const util::graph::CostFunc<N, E, C>& costFunc,
+                      const util::graph::HeurFunc<N, E, C>& heurFunc,
                       PQ<N, E, C>& pq) {
   if (cur.e->getFrom()->hasEdgeIn(cur.e)) {
     // for undirected graphs
@@ -224,6 +238,7 @@ void EDijkstra::relax(RouteEdge<N, E, C>& cur, const std::set<Edge<N, E>*>& to,
       if (costFunc.inf() <= newC) continue;
 
       const C& h = heurFunc(edge, to);
+      // addition done here to avoid it in the PQ
       const C& newH = newC + h;
 
       pq.emplace(edge, cur.e, cur.e->getFrom(), newC, newH);
@@ -237,6 +252,7 @@ void EDijkstra::relax(RouteEdge<N, E, C>& cur, const std::set<Edge<N, E>*>& to,
     if (costFunc.inf() <= newC) continue;
 
     const C& h = heurFunc(edge, to);
+    // addition done here to avoid it in the PQ
     const C& newH = newC + h;
 
     pq.emplace(edge, cur.e, cur.e->getTo(), newC, newH);
@@ -249,7 +265,7 @@ void EDijkstra::buildPath(Edge<N, E>* curE, const Settled<N, E, C>& settled,
                           NList<N, E>* resNodes, EList<N, E>* resEdges) {
   const RouteEdge<N, E, C>* curEdge = &settled.find(curE)->second;
   if (resNodes) resNodes->push_back(curEdge->e->getOtherNd(curEdge->n));
-  while (true) {
+  while (resNodes || resEdges) {
     if (resNodes && curEdge->n) resNodes->push_back(curEdge->n);
     if (resEdges) resEdges->push_back(curEdge->e);
     if (!curEdge->parent) break;

src/util/graph/Edge.h

@@ -21,9 +21,6 @@ class Edge {
 
   Node<N, E>* getOtherNd(const Node<N, E>* notNode) const;
 
-  void setFrom(Node<N, E>* from);
-  void setTo(Node<N, E>* to);
-
   E& pl();
   const E& pl() const;
 

src/util/graph/Graph.h

@@ -32,6 +32,8 @@ class Graph {
   const std::set<Node<N, E>*>& getNds() const;
   std::set<Node<N, E>*>* getNds();
 
+  static Node<N, E>* sharedNode(const Edge<N, E>* a, const Edge<N, E>* b);
+
   typename std::set<Node<N, E>*>::iterator delNd(Node<N, E>* n);
   typename std::set<Node<N, E>*>::iterator delNd(
       typename std::set<Node<N, E>*>::iterator i);

src/util/graph/Graph.tpp

@@ -67,6 +67,17 @@ Edge<N, E>* Graph<N, E>::getEdg(Node<N, E>* from, Node<N, E>* to) {
 
 // _____________________________________________________________________________
 template <typename N, typename E>
+Node<N, E>* Graph<N, E>::sharedNode(const Edge<N, E>* a, const Edge<N, E>* b) {
+  Node<N, E>* r = 0;
+  if (a->getFrom() == b->getFrom() || a->getFrom() == b->getTo())
+    r = a->getFrom();
+  if (a->getTo() == b->getFrom() || a->getTo() == b->getTo()) r = a->getTo();
+  return r;
+}
+
+
+// _____________________________________________________________________________
+template <typename N, typename E>
 const Edge<N, E>* Graph<N, E>::getEdg(Node<N, E>* from, Node<N, E>* to) const {
   for (auto e : from->getAdjList()) {
     if (e->getOtherNd(from) == to) return e;

src/util/graph/ShortestPath.h

@@ -19,9 +19,47 @@
 namespace util {
 namespace graph {
 
+using util::graph::Edge;
 using util::graph::Graph;
 using util::graph::Node;
-using util::graph::Edge;
+
+template <typename N, typename E>
+using EList = std::vector<Edge<N, E>*>;
+
+template <typename N, typename E>
+using NList = std::vector<Node<N, E>*>;
+
+template <typename N, typename E, typename C>
+struct CostFunc {
+  virtual C operator()(const Node<N, E>* from, const Edge<N, E>* e,
+                       const Node<N, E>* to) const = 0;
+  virtual C operator()(const Edge<N, E>* from, const Node<N, E>* n,
+                       const Edge<N, E>* to) const = 0;
+  virtual C inf() const = 0;
+};
+
+
+template <typename N, typename E, typename C>
+struct HeurFunc {
+  virtual C operator()(const Node<N, E>* a,
+                       const std::set<Node<N, E>*>& b) const = 0;
+  virtual C operator()(const Edge<N, E>* a,
+                       const std::set<Edge<N, E>*>& b) const = 0;
+};
+
+template <typename N, typename E, typename C>
+struct ZeroHeurFunc : public HeurFunc<N, E, C> {
+  C operator()(const Node<N, E>* a, const std::set<Node<N, E>*>& b) const {
+    UNUSED(a);
+    UNUSED(b);
+    return C();
+  }
+  C operator()(const Edge<N, E>* a, const std::set<Edge<N, E>*>& b) const {
+    UNUSED(a);
+    UNUSED(b);
+    return C();
+  }
+};
 
 // shortest path base class
 template <class D>
@@ -34,37 +72,6 @@ class ShortestPath {
   using NList = std::vector<Node<N, E>*>;
 
   template <typename N, typename E, typename C>
-  struct CostFunc {
-    virtual C operator()(const Node<N, E>* from, const Edge<N, E>* e,
-                         const Node<N, E>* to) const = 0;
-    virtual C operator()(const Edge<N, E>* from, const Node<N, E>* n,
-                         const Edge<N, E>* to) const = 0;
-    virtual C inf() const = 0;
-  };
-
-  template <typename N, typename E, typename C>
-  struct HeurFunc {
-    virtual C operator()(const Node<N, E>* a,
-                         const std::set<Node<N, E>*>& b) const = 0;
-    virtual C operator()(const Edge<N, E>* a,
-                         const std::set<Edge<N, E>*>& b) const = 0;
-  };
-
-  template <typename N, typename E, typename C>
-  struct ZeroHeurFunc : public HeurFunc<N, E, C> {
-    C operator()(const Node<N, E>* a, const std::set<Node<N, E>*>& b) const {
-      UNUSED(a);
-      UNUSED(b);
-      return C();
-    }
-    C operator()(const Edge<N, E>* a, const std::set<Edge<N, E>*>& b) const {
-      UNUSED(a);
-      UNUSED(b);
-      return C();
-    }
-  };
-
-  template <typename N, typename E, typename C>
   static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
                         const CostFunc<N, E, C>& costFunc,
                         const HeurFunc<N, E, C>& heurFunc,
@@ -74,7 +81,8 @@ class ShortestPath {
   }
 
   template <typename N, typename E, typename C>
-  static C shortestPath(const std::set<Node<N, E>*> from, const std::set<Node<N, E>*>& to,
+  static C shortestPath(const std::set<Node<N, E>*> from,
+                        const std::set<Node<N, E>*>& to,
                         const CostFunc<N, E, C>& costFunc,
                         const HeurFunc<N, E, C>& heurFunc,
                         EList<N, E>* resEdges, NList<N, E>* resNodes) {
@@ -83,6 +91,15 @@ class ShortestPath {
   }
 
   template <typename N, typename E, typename C>
+  static C shortestPath(const std::set<Node<N, E>*> from,
+                        const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        EList<N, E>* resEdges, NList<N, E>* resNodes) {
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(),
+                               resEdges, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
   static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
                         const CostFunc<N, E, C>& costFunc,
                         EList<N, E>* resEdges, NList<N, E>* resNodes) {
@@ -161,6 +178,14 @@ class ShortestPath {
   }
 
   template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& tos,
+                        const CostFunc<N, E, C>& costFunc) {
+    EList<N, E>* el = 0;
+    NList<N, E>* nl = 0;
+    return shortestPath(from, tos, costFunc, el, nl);
+  }
+
+  template <typename N, typename E, typename C>
   static C shortestPath(Node<N, E>* from, Node<N, E>* to,
                         const CostFunc<N, E, C>& costFunc) {
     if (to->getInDeg() == 0) return costFunc.inf();
@@ -266,7 +291,7 @@ class ShortestPath {
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPath(
       Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
-      const ShortestPath::CostFunc<N, E, C>& costFunc,
+      const CostFunc<N, E, C>& costFunc,
       const HeurFunc<N, E, C>& heurFunc,
       std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
       std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes) {
@@ -277,7 +302,7 @@ class ShortestPath {
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPath(
       Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
-      const ShortestPath::CostFunc<N, E, C>& costFunc,
+      const CostFunc<N, E, C>& costFunc,
       const HeurFunc<N, E, C>& heurFunc,
       std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges) {
     std::unordered_map<Edge<N, E>*, NList<N, E>*> dummyRet;
@@ -288,7 +313,7 @@ class ShortestPath {
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPath(
       Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
-      const ShortestPath::CostFunc<N, E, C>& costFunc,
+      const CostFunc<N, E, C>& costFunc,
       const HeurFunc<N, E, C>& heurFunc) {
     std::unordered_map<Edge<N, E>*, NList<N, E>*> dummyRet;
     std::unordered_map<Edge<N, E>*, EList<N, E>*> dummyRetE;
@@ -299,22 +324,21 @@ class ShortestPath {
   template <typename N, typename E, typename C>
   static C shortestPath(const std::set<Edge<N, E>*>& from,
                         const std::set<Edge<N, E>*>& to,
-                        const CostFunc<N, E, C>& costFunc,
-                        const HeurFunc<N, E, C>& heurFunc) {
+                        const CostFunc<N, E, C>& costFunc) {
     NList<N, E>* nl = 0;
     EList<N, E>* el = 0;
-    return D::shortestPathImpl(from, to, costFunc, heurFunc, el, nl);
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(), el,
+                               nl);
   }
 
   template <typename N, typename E, typename C>
-  static C shortestPath(Edge<N, E>* from,
-                        Edge<N, E>* to,
-                        const CostFunc<N, E, C>& costFunc ) {
+  static C shortestPath(const std::set<Edge<N, E>*>& from,
+                        const std::set<Edge<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc) {
     NList<N, E>* nl = 0;
     EList<N, E>* el = 0;
-    std::set<Edge<N, E>*> tos{to};
-    std::set<Edge<N, E>*> froms{from};
-    return D::shortestPathImpl(froms, tos, costFunc, ZeroHeurFunc<N, E, C>(), el, nl);
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, el, nl);
   }
 
   template <typename N, typename E, typename C>
@@ -327,6 +351,17 @@ class ShortestPath {
   }
 
   template <typename N, typename E, typename C>
+  static C shortestPath(Edge<N, E>* from, Edge<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc) {
+    NList<N, E>* nl = 0;
+    EList<N, E>* el = 0;
+    std::set<Edge<N, E>*> tos{to};
+    std::set<Edge<N, E>*> froms{from};
+    return D::shortestPathImpl(froms, tos, costFunc, ZeroHeurFunc<N, E, C>(),
+                               el, nl);
+  }
+
+  template <typename N, typename E, typename C>
   static C shortestPath(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
                         const CostFunc<N, E, C>& costFunc,
                         const HeurFunc<N, E, C>& heurFunc, EList<N, E>* el,
@@ -336,8 +371,7 @@ class ShortestPath {
 
   template <typename N, typename E, typename C>
   static C shortestPath(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
-                        const CostFunc<N, E, C>& costFunc,
-                        EList<N, E>* el,
+                        const CostFunc<N, E, C>& costFunc, EList<N, E>* el,
                         NList<N, E>* nl) {
     return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(), el,
                                nl);
@@ -363,24 +397,21 @@ class ShortestPath {
 
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPath(
-      Edge<N, E>* from,
-      const ShortestPath::CostFunc<N, E, C>& costFunc) {
-    std::set<Edge<N, E>*> froms { from };
+      Edge<N, E>* from, const CostFunc<N, E, C>& costFunc) {
+    std::set<Edge<N, E>*> froms{from};
     return D::shortestPathImpl(froms, costFunc, false);
   }
 
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPathRev(
-      Edge<N, E>* from,
-      const ShortestPath::CostFunc<N, E, C>& costFunc) {
-    std::set<Edge<N, E>*> froms { from };
+      Edge<N, E>* from, const CostFunc<N, E, C>& costFunc) {
+    std::set<Edge<N, E>*> froms{from};
     return D::shortestPathImpl(froms, costFunc, true);
   }
 
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPath(
-      Node<N, E>* from,
-      const ShortestPath::CostFunc<N, E, C>& costFunc) {
+      Node<N, E>* from, const CostFunc<N, E, C>& costFunc) {
     std::set<Edge<N, E>*> froms;
     froms.insert(from->getAdjListOut().begin(), from->getAdjListOut().end());
     return D::shortestPathImpl(froms, costFunc, false);
@@ -388,14 +419,13 @@ class ShortestPath {
 
   template <typename N, typename E, typename C>
   static std::unordered_map<Edge<N, E>*, C> shortestPathRev(
-      Node<N, E>* from,
-      const ShortestPath::CostFunc<N, E, C>& costFunc) {
+      Node<N, E>* from, const CostFunc<N, E, C>& costFunc) {
     std::set<Edge<N, E>*> froms;
     froms.insert(from->getAdjListOut().begin(), from->getAdjListOut().end());
     return D::shortestPathImpl(froms, costFunc, true);
   }
 };
-}
-}
+}  // namespace graph
+}  // namespace util
 
 #endif  // UTIL_GRAPH_SHORTESTPATH_H_

src/util/http/Server.cpp

@@ -22,6 +22,7 @@
 #include <vector>
 #include "Server.h"
 #include "util/String.h"
+#include "util/log/Log.h"
 
 using util::http::Socket;
 using util::http::Queue;
@@ -112,7 +113,12 @@ void HttpServer::handle() {
       answ = Answer("500 Internal Server Error", "500 Internal Server Error");
     }
 
-    send(connection, &answ);
+    try {
+      send(connection, &answ);
+    } catch (const std::runtime_error& err) {
+      LOG(WARN) << err.what();
+    }
+
     close(connection);
   }
 }

src/util/log/Log.h

@@ -19,8 +19,12 @@
 #define LOGLEVEL 2
 #endif
 
+#define GET_MACRO(_1,_2,NAME,...) NAME
+#define LOG(...) GET_MACRO(__VA_ARGS__, LOGSTR, LOGAUTO)(__VA_ARGS__)
+
 // compiler will optimize statement away if x > LOGLEVEL
-#define LOG(x) if (x <= LOGLEVEL) util::Log<x>().log()
+#define LOGAUTO(x) if (x <= LOGLEVEL) util::Log<x>().log()
+#define LOGSTR(x, os) if (x <= LOGLEVEL) util::Log<x>(&os).log()
 
 using std::setfill;
 using std::setw;
@@ -33,7 +37,8 @@ static const char* LOGS[] = {"ERROR", "WARN ", "INFO ", "DEBUG", "DEBUG"};
 template <char LVL>
 class Log {
  public:
-  Log() { if (LVL == ERROR) os = &std::cerr; else os = &std::cout; }
+  Log() { if (LVL < INFO) os = &std::cerr; else os = &std::cout; }
+  Log(std::ostream* s) { os = s; }
   ~Log() { (*os) << std::endl; }
   std::ostream& log() { return ts() << LOGS[(size_t)LVL] << ": "; }
 

src/util/tests/QuadTreeTest.cpp

@@ -0,0 +1,38 @@
+// Copyright 2016
+// Author: Patrick Brosi
+
+#include "util/Misc.h"
+#include "util/geo/QuadTree.h"
+#include "util/tests/QuadTreeTest.h"
+
+using util::approx;
+using util::geo::QuadTree;
+using util::geo::DPoint;
+using util::geo::DBox;
+
+// _____________________________________________________________________________
+void QuadTreeTest::run() {
+  // ___________________________________________________________________________
+  {
+    QuadTree<int, double> qt(4, 4, DBox(DPoint(0, 0), DPoint(10, 10)));
+
+    qt.insert(0, {2, 2});
+    TEST(qt.size(), ==, 1);
+
+    qt.insert(666, {-1, 0});
+    TEST(qt.size(), ==, 1);
+
+    qt.insert(1, {0, 0});
+    TEST(qt.size(), ==, 2);
+
+    qt.insert(2, {0, 1});
+    TEST(qt.size(), ==, 3);
+
+    qt.insert(3, {6, 9});
+    TEST(qt.size(), ==, 4);
+
+    qt.insert(4, {9, 0});
+    TEST(qt.size(), ==, 5);
+  }
+
+}

src/util/tests/QuadTreeTest.h

@@ -0,0 +1,12 @@
+// Copyright 2016
+// Author: Patrick Brosi
+
+#ifndef UTIL_TEST_QUADTTREETEST_H_
+#define UTIL_TEST_QUADTREETEST_H_
+
+class QuadTreeTest {
+  public:
+    void run();
+};
+
+#endif

web/script.js

@@ -187,12 +187,6 @@ function renderStat(stat) {
         suggList.appendChild(suggDiv);
     }
 
-    if (map.getZoom() < 18) {
-        map.setView(ll, 18, {
-            animate: true
-        });
-    }
-
     L.popup({
             opacity: 0.8
         })
@@ -347,15 +341,8 @@ function renderGroup(grp, ll) {
 
     content.appendChild(suggD);
 
-    if (map.getZoom() < 18) {
-        map.setView(ll, 18, {
-            animate: true
-        });
-    }
 
-    L.popup({
-            opacity: 0.8
-        })
+    L.popup({opacity: 0.8})
         .setLatLng(ll)
         .setContent(content)
         .openOn(map)
@@ -411,7 +398,7 @@ function nodeUnHl(id) {
 
     if (map.getZoom() > 15) {
         document.nodeIdx[id].setStyle({
-            'weight': 1,
+            'weight': map.getZoom() > 17 ? 1.5 : 1,
             'color': "black"
         });
     } else {
@@ -431,6 +418,12 @@ map.addControl(L.control.attribution({
     prefix: '&copy; <a href="http://ad.cs.uni-freiburg.de">University of Freiburg, Chair of Algorithms and Data Structures</a>'
 }));
 
+map.on('popupopen', function(e) {
+    var px = map.project(e.target._popup._latlng);
+    px.y -= e.target._popup._container.clientHeight/2;
+    map.panTo(map.unproject(px),{animate: true});
+});
+
 L.tileLayer('http://{s}.tile.stamen.com/toner-lite/{z}/{x}/{y}.png', {
     maxZoom: 20,
     attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>',
@@ -480,7 +473,6 @@ function render() {
                     blur: blur - 3,
                     radius: Math.min(12, rad - 3)
                 }));
-
                 layer.addLayer(L.heatLayer(content.err, {
                     max: 500,
                     gradient: {
@@ -538,6 +530,10 @@ function render() {
                     }));
                 }
 
+                layer.addLayer(L.featureGroup(stations).on('click', function(a) {
+                    openStat(a.layer.options.id);
+                }));
+
                 if (map.getZoom() > 15) {
                     labelLayer.addLayer(L.featureGroup(labels));
                     layer.addLayer(L.featureGroup(suggs).on('click', function(a) {
@@ -545,10 +541,6 @@ function render() {
                     }));
                 }
 
-                layer.addLayer(L.featureGroup(stations).on('click', function(a) {
-                    openStat(a.layer.options.id);
-                }));
-
                 groupHl(openGr);
                 nodeHl(openSt);
             }
@@ -559,4 +551,102 @@ function render() {
     }
 }
 
+function rowClick(row) {    
+    if (!isSearchOpen()) return;
+    openGroup(row.gid, row.latlng);
+    document.getElementById('searchinput').value = "";
+    search();
+}
+
+function select(row) {
+    if (!isSearchOpen()) return;
+    if (window.selectedRes) window.selectedRes.className = "searchres";    
+    row.className = "searchres selected-res";
+    window.selectedRes = row;
+}
+
+function unselect(row) {    
+    window.selectedRes = undefined;
+    if (row) row.className = "searchres";
+}
+
+function isSearchOpen() {
+    return document.getElementById("searchresults").className == "res-open";
+}
+
+function search(q) {
+    var delay = 0;
+    if (q == window.prevSearch) return;
+    clearTimeout(window.delayTimer);
+    window.prevSearch = q;
+    if (!q) {
+        unselect(window.selectedRes);
+        var res = document.getElementById("searchresults");
+        res.className = "";
+        return;
+    }
+
+    window.delayTimer = setTimeout(function() {
+        window.searchhttp = new XMLHttpRequest();
+        window.searchhttp.open("GET", backend + "/search?q=" + q, true);
+        window.searchhttp.send();
+
+        window.searchhttp.onreadystatechange = function() {
+            if (this.readyState == 4 && this.status == 200 && this == window.searchhttp) {
+                var content = JSON.parse(this.responseText);
+                var res = document.getElementById("searchresults");
+                res.className = "res-open";        
+                res.innerHTML = "";
+                for (var i = 0; i < content.length; i++) {
+                    stat = content[i];
+                    var row = document.createElement('span');
+                    row.className="searchres";
+                    row.innerHTML = stat.name;
+                    row.gid = stat.gid;
+                    row.latlng = stat.latlng;
+                    row.onmouseover = function(){select(this)};
+                    row.onclick = function(){rowClick(this)};
+                    if (stat.via && stat.via != stat.name) {
+                        var via = document.createElement('span');
+                        via.className="via";
+                        via.innerHTML = stat.via;
+                        row.appendChild(via);
+                    }
+                    res.appendChild(row);
+                }
+            }
+        }
+    }, delay);
+}
+
+function keypress(e) {
+    if (e.keyCode == 40) {
+        var sels = document.getElementsByClassName('selected-res')
+        if (sels.length) {
+            var selected = sels[0];
+            if (selected.nextSibling) select(selected.nextSibling);
+        } else {
+           var res = document.getElementsByClassName('searchres') 
+           if (res.length) select(res[0]);
+        }
+    } else if (e.keyCode == 38) {
+        var sels = document.getElementsByClassName('selected-res')
+        if (sels.length) {
+            var selected = sels[0];
+            if (selected.previousSibling) select(selected.previousSibling);
+            else unselect(selected);
+        }
+    }
+
+    if (e.keyCode == 13) {
+        var sels = document.getElementsByClassName('selected-res');
+        if (sels.length) rowClick(sels[0]);
+    }
+}
+
+document.getElementById('del').onclick = function() {
+    document.getElementById('searchinput').value = "";
+    search();
+}
+
 render();