tweaks

src/osmfixer/index/StatIdx.cpp

@@ -12,6 +12,7 @@
 #include "util/log/Log.h"
 
 using osmfixer::Group;
+using osmfixer::MetaGroup;
 using osmfixer::OsmAttrs;
 using osmfixer::StatIdx;
 using osmfixer::Station;
@@ -170,8 +171,26 @@ void StatIdx::readFromFile(const std::string& path) {
   }
   LOG(INFO) << "Done.";
 
+  // fifth, parse meta groups
+  LOG(INFO) << "Parsing meta groups... ";
+  while (std::getline(f, line)) {
+    // empty line is separator between blocks
+    if (line.size() == 0) break;
+
+    std::stringstream rec(line);
+    size_t gid, osmid;
+
+    rec >> gid;
+    rec >> osmid;
+
+    addGroupToMeta(gid, osmid);
+  }
+
+  LOG(INFO) << "Done.";
+
   LOG(INFO) << "Building indices...";
   initGroups();
+  initMetaGroups();
   initSuggestions();
 
   initIndex();
@@ -179,6 +198,13 @@ void StatIdx::readFromFile(const std::string& path) {
 }
 
 // _____________________________________________________________________________
+void StatIdx::addGroupToMeta(size_t gid, size_t metaId) {
+  _groups[gid].metaGroupId = metaId;
+  _metaGroups[metaId].osmid = metaId;
+  _metaGroups[metaId].groups.push_back(gid);
+}
+
+// _____________________________________________________________________________
 void StatIdx::addStation(int64_t osmid, const util::geo::DLine& geom,
                          const util::geo::DLine& latLngs, size_t origGroup,
                          size_t group, const OsmAttrs& attrs) {
@@ -203,11 +229,33 @@ void StatIdx::addGroup(size_t osmid, const OsmAttrs& attrs) {
   Group g;
   g.id = _groups.size();
   g.osmid = osmid;
+  g.metaGroupId = 0;
+  g.mergeId = 0;
   g.attrs = attrs;
   _groups.emplace_back(g);
 }
 
 // _____________________________________________________________________________
+void StatIdx::initMetaGroups() {
+  // build hull polygons
+  for (auto& p : _metaGroups) {
+    auto& mg = p.second;
+    util::geo::MultiPoint<double> mp;
+    for (size_t gid : mg.groups) {
+      for (auto p : _groups[gid].poly.getOuter()) mp.push_back(p);
+      mg.poly = hull(mp, 11);
+    }
+
+    for (auto p : mg.poly.getOuter()) {
+      mg.llPoly.getOuter().push_back(
+          util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
+    }
+
+    mg.centroid = util::geo::centroid(mg.llPoly);
+  }
+}
+
+// _____________________________________________________________________________
 void StatIdx::initGroups() {
   for (size_t i = 0; i < _stations.size(); i++) {
     // this should be ensured by the input file
@@ -220,6 +268,16 @@ void StatIdx::initGroups() {
       _groups[_stations[i].origGroup].stations.push_back(i);
     }
 
+    if (_stations[i].group != _stations[i].origGroup &&
+        _groups[_stations[i].group].osmid > 2 &&
+        _groups[_stations[i].origGroup].osmid > 2) {
+      auto& orGr = _groups[_stations[i].origGroup];
+      if (orGr.mergeId == 0)
+        orGr.mergeId = _stations[i].group;
+      else if (orGr.mergeId != _stations[i].group)
+        orGr.mergeId = _stations[i].group;
+    }
+
     assert(_stations[i].group < _groups.size());
     if (_stations[i].group != _stations[i].origGroup &&
         _groups[_stations[i].group].osmid == 1) {
@@ -259,6 +317,14 @@ void StatIdx::initGroups() {
               byAttrScore);
   }
 
+  ByErrId byErrId(_stations);
+
+  // sort stations by error or sugg occurance
+  for (size_t gid = 0; gid < _groups.size(); gid++) {
+    std::sort(_groups[gid].stations.begin(), _groups[gid].stations.end(),
+              byErrId);
+  }
+
   // build hull polygon
   for (size_t i = 0; i < _groups.size(); i++) {
     util::geo::MultiPoint<double> mp;
@@ -307,6 +373,8 @@ void StatIdx::initIndex() {
                                                                _bbox, false);
   _ggrid = util::geo::Grid<size_t, util::geo::Polygon, double>(gSize, gSize,
                                                                _bbox, false);
+  _mgrid = util::geo::Grid<size_t, util::geo::Polygon, double>(gSize, gSize,
+                                                               _bbox, false);
   _suggrid = util::geo::Grid<size_t, util::geo::Line, double>(gSize, gSize,
                                                               _bbox, false);
 
@@ -315,6 +383,10 @@ void StatIdx::initIndex() {
     if (_groups[i].polyStations.size() == 1 && _groups[i].osmid < 2) continue;
     _ggrid.add(_groups[i].poly, i);
   }
+  for (const auto& gp : _metaGroups) {
+    if (gp.second.poly.getOuter().size() < 2) continue;
+    _mgrid.add(gp.second.poly, gp.first);
+  }
   for (size_t i = 0; i < _suggestions.size(); i++)
     _suggrid.add(_suggestions[i].arrow, i);
 
@@ -417,6 +489,27 @@ void StatIdx::initIndex() {
 }
 
 // _____________________________________________________________________________
+std::vector<const MetaGroup*> StatIdx::getMetaGroups(
+    const util::geo::DBox bbox) const {
+  std::vector<const MetaGroup*> ret;
+  auto ll = util::geo::latLngToWebMerc<double>(bbox.getLowerLeft().getX(),
+                                               bbox.getLowerLeft().getY());
+  auto ur = util::geo::latLngToWebMerc<double>(bbox.getUpperRight().getX(),
+                                               bbox.getUpperRight().getY());
+
+  std::set<size_t> tmp;
+  auto reqBox = util::geo::DBox(ll, ur);
+  _mgrid.get(reqBox, &tmp);
+
+  for (auto i : tmp) {
+    if (util::geo::intersects(_metaGroups.find(i)->second.poly, reqBox))
+      ret.push_back(&_metaGroups.find(i)->second);
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
 std::vector<const Suggestion*> StatIdx::getSuggestions(
     const util::geo::DBox bbox) const {
   std::vector<const Suggestion*> ret;
@@ -582,6 +675,37 @@ void StatIdx::initSuggestions() {
     Suggestion sug;
     sug.station = i;
 
+    if (group.mergeId != 0 && group.mergeId != group.id) {
+      if (getGroup(group.mergeId)->metaGroupId) {
+        // move group into meta group
+        sug.type = 10;
+        sug.station = -group.id;
+        sug.orig_gid = 0;
+        sug.orig_osm_rel_id = 0;
+        sug.target_gid = getGroup(group.mergeId)->metaGroupId;
+        sug.target_osm_rel_id = getGroup(group.mergeId)->metaGroupId;
+
+        auto a = util::geo::centroid(group.poly);
+        auto b = util::geo::centroid(
+            getMetaGroup(getGroup(group.mergeId)->metaGroupId)->poly);
+        sug.arrow = getGroupArrow(a, b);
+      } else {
+        // merge two groups
+        sug.type = 9;
+        sug.station = -group.id;
+        sug.orig_gid = 0;
+        sug.orig_osm_rel_id = 0;
+        sug.target_gid = group.mergeId;
+        sug.target_osm_rel_id = getGroup(group.mergeId)->osmid;
+        auto a = util::geo::centroid(group.poly);
+        auto b = util::geo::centroid(getGroup(group.mergeId)->poly);
+        sug.arrow = getGroupArrow(a, b);
+      }
+
+      _suggestions.push_back(sug);
+      group.suggestions.push_back(_suggestions.size() - 1);
+    }
+
     std::set<std::pair<std::string, uint16_t>> suggested;
     for (auto attrErr : group.attrErrs) {
       if (!attrErr.fromRel) continue;
@@ -620,8 +744,10 @@ void StatIdx::initSuggestions() {
   // station suggestions
   for (size_t i = 0; i < _stations.size(); i++) {
     auto& stat = _stations[i];
+    auto centroid = util::geo::centroid(stat.pos);
 
-    if (stat.attrs.count("name") == 0 && _groups[stat.group].attrs.count("name") == 0) {
+    if (stat.attrs.count("name") == 0 &&
+        _groups[stat.group].attrs.count("name") == 0) {
       Suggestion sug;
       sug.station = i;
       sug.type = 7;
@@ -672,8 +798,6 @@ void StatIdx::initSuggestions() {
     if (stat.group != stat.origGroup || getGroup(stat.group)->osmid == 1) {
       Suggestion sug;
       sug.station = i;
-      auto centroid = util::geo::centroid(stat.pos);
-      sug.arrow = util::geo::DLine{centroid, centroid};
 
       if (getGroup(stat.origGroup)->osmid < 2) {
         if (getGroup(stat.group)->osmid == 1 &&
@@ -692,7 +816,7 @@ void StatIdx::initSuggestions() {
           sug.target_osm_rel_id = getGroup(stat.group)->osmid;
 
           auto b = util::geo::centroid(getGroup(stat.group)->poly);
-          sug.arrow = getGroupArrow(i, b);
+          sug.arrow = getGroupArrow(centroid, b);
 
           _suggestions.push_back(sug);
           stat.suggestions.push_back(_suggestions.size() - 1);
@@ -707,20 +831,37 @@ void StatIdx::initSuggestions() {
           sug.target_gid = stat.group;
 
           auto b = util::geo::centroid(getGroup(stat.group)->poly);
-          sug.arrow = getGroupArrow(i, b);
+          sug.arrow = getGroupArrow(centroid, b);
 
           _suggestions.push_back(sug);
           stat.suggestions.push_back(_suggestions.size() - 1);
         } else if (getGroup(stat.group)->osmid > 1) {
-          // move station from relation into existing group
-          sug.type = 4;
+          if (stat.group != getGroup(stat.origGroup)->mergeId) {
+            // move station from relation into existing group
+            sug.type = 4;
+            sug.target_gid = stat.group;
+            sug.target_osm_rel_id = getGroup(stat.group)->osmid;
+
+            // dont output arrow if move is part of a group merge
+            auto b = util::geo::centroid(getGroup(stat.group)->poly);
+            sug.arrow = getGroupArrow(centroid, b);
+          } else {
+            continue;
+            // size_t metaId =
+            // getGroup(getGroup(stat.origGroup)->mergeId)->metaGroupId;
+            // if (metaId) {
+            // sug.type = 10;
+            // sug.target_gid = metaId;
+            // sug.target_osm_rel_id = metaId;
+            // } else {
+            // sug.type = 9;
+            // sug.target_gid = stat.group;
+            // sug.target_osm_rel_id = getGroup(stat.group)->osmid;
+            // }
+          }
+
           sug.orig_gid = stat.origGroup;
           sug.orig_osm_rel_id = getGroup(stat.origGroup)->osmid;
-          sug.target_gid = stat.group;
-          sug.target_osm_rel_id = getGroup(stat.group)->osmid;
-
-          auto b = util::geo::centroid(getGroup(stat.group)->poly);
-          sug.arrow = getGroupArrow(i, b);
 
           _suggestions.push_back(sug);
           stat.suggestions.push_back(_suggestions.size() - 1);
@@ -738,7 +879,7 @@ void StatIdx::initSuggestions() {
           b.setX(b.getX() + 50);
           b.setY(b.getY() + 50);
 
-          sug.arrow = getGroupArrow(i, b);
+          sug.arrow = getGroupArrow(centroid, b);
 
           _suggestions.push_back(sug);
           stat.suggestions.push_back(_suggestions.size() - 1);
@@ -749,10 +890,8 @@ void StatIdx::initSuggestions() {
 }
 
 // _____________________________________________________________________________
-util::geo::DLine StatIdx::getGroupArrow(size_t stat,
+util::geo::DLine StatIdx::getGroupArrow(const util::geo::DPoint& a,
                                         const util::geo::DPoint& b) const {
-  auto a = util::geo::centroid(getStation(stat)->pos);
-
   auto pl = util::geo::PolyLine<double>(a, b);
   auto bb = pl.getPointAtDist(fmax(pl.getLength() / 2, pl.getLength() - 5)).p;
 
@@ -804,6 +943,12 @@ const Group* StatIdx::getGroup(size_t id) const {
 }
 
 // _____________________________________________________________________________
+const MetaGroup* StatIdx::getMetaGroup(size_t id) const {
+  if (_metaGroups.count(id)) return &_metaGroups.find(id)->second;
+  return 0;
+}
+
+// _____________________________________________________________________________
 int StatIdx::nameAttrRel(const std::string& attr) const {
   if (attr == "uic_name") return 5;
   if (attr == "ref_name") return 5;

src/osmfixer/index/StatIdx.h

@@ -16,7 +16,7 @@ namespace osmfixer {
 typedef std::map<std::string, std::vector<std::string>> OsmAttrs;
 
 inline bool byAttrScore(const std::pair<int, std::string>& lh,
-                  const std::pair<int, std::string>& rh) {
+                        const std::pair<int, std::string>& rh) {
   return lh.first > rh.first;
 }
 
@@ -34,13 +34,21 @@ struct AttrErr {
 
 struct Suggestion {
   uint16_t type;
-  size_t station;
+  int64_t station;
   // if negative, it is a way!
   int64_t target_gid, orig_gid, target_osm_rel_id, orig_osm_rel_id;
   std::string attrErrName;
   util::geo::DLine arrow;
 };
 
+struct MetaGroup {
+  size_t osmid;
+  util::geo::DPolygon poly;
+  util::geo::DPolygon llPoly;
+  util::geo::DPoint centroid;
+  std::vector<size_t> groups;
+};
+
 struct Station {
   size_t id;
   // if negative, it is a way!
@@ -60,9 +68,23 @@ inline bool byErr(const Station* lh, const Station* rh) {
   return a < b;
 }
 
+struct ByErrId {
+  ByErrId(const std::vector<Station>& stats) : stats(stats) {}
+  bool operator()(int64_t lhId, int64_t rhId) {
+    const auto& lh = stats[lhId];
+    const auto& rh = stats[rhId];
+    size_t a = lh.attrErrs.size() ? 2 : lh.suggestions.size() ? 1 : 0;
+    size_t b = rh.attrErrs.size() ? 2 : rh.suggestions.size() ? 1 : 0;
+    return a > b;
+  }
+  const std::vector<Station>& stats;
+};
+
 struct Group {
   size_t id;
   int64_t osmid;
+  size_t mergeId;
+  size_t metaGroupId;
   util::geo::DPolygon poly;
   util::geo::DPolygon llPoly;
   util::geo::DPoint centroid;
@@ -95,10 +117,12 @@ class StatIdx {
   std::vector<const Group*> getGroups(const util::geo::DBox bbox) const;
   std::vector<const Suggestion*> getSuggestions(
       const util::geo::DBox bbox) const;
+  std::vector<const MetaGroup*> getMetaGroups(const util::geo::DBox bbox) const;
 
   const Station* getStation(size_t id) const;
   const Group* getGroup(size_t id) const;
   const Suggestion* getSuggestion(size_t id) const;
+  const MetaGroup* getMetaGroup(size_t id) const;
 
   std::vector<Cluster> getHeatGridOk(const util::geo::DBox bbox,
                                      size_t z) const;
@@ -117,14 +141,17 @@ class StatIdx {
                   const util::geo::DLine& latLngs, size_t origGroup,
                   size_t group, const OsmAttrs& attrs);
   void addGroup(size_t id, const OsmAttrs& attrs);
+  void addGroupToMeta(size_t gid, size_t metaId);
 
   void initIndex();
   void initGroups();
+  void initMetaGroups();
   void initSuggestions();
 
   int nameAttrRel(const std::string& attr) const;
 
-  util::geo::DLine getGroupArrow(size_t stat, const util::geo::DPoint& p) const;
+  util::geo::DLine getGroupArrow(const util::geo::DPoint& a,
+                                 const util::geo::DPoint& p) const;
 
   util::geo::Polygon<double> hull(const util::geo::MultiPoint<double>& imp,
                                   double rad) const;
@@ -132,10 +159,12 @@ class StatIdx {
   std::vector<Station> _stations;
   std::vector<Group> _groups;
   std::vector<Suggestion> _suggestions;
+  std::map<size_t, MetaGroup> _metaGroups;
   util::geo::DBox _bbox;
 
   util::geo::Grid<size_t, util::geo::Polygon, double> _sgrid;
   util::geo::Grid<size_t, util::geo::Polygon, double> _ggrid;
+  util::geo::Grid<size_t, util::geo::Polygon, double> _mgrid;
   util::geo::Grid<size_t, util::geo::Line, double> _suggrid;
 
   std::vector<util::geo::Grid<Cluster, util::geo::Point, double>> _heatGridsOk;

src/osmfixer/server/StatServer.cpp

@@ -45,6 +45,8 @@ util::http::Answer StatServer::handle(const util::http::Req& req,
       a = handleStatReq(params);
     } else if (cmd == "/group") {
       a = handleGroupReq(params);
+    } else if (cmd == "/mgroup") {
+      a = handleMGroupReq(params);
     } else if (cmd == "/search") {
       a = handleSearch(params);
     } else {
@@ -228,6 +230,7 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
 
       const auto& suggs = idx.getSuggestions(bbox);
       for (const auto& sugg : suggs) {
+        if (sugg->arrow.size() < 2) continue;
         json << sep;
         sep = ',';
         printSugg(sugg, did, &json);
@@ -235,6 +238,21 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
     }
   }
 
+  json << "], \"mgroups\":[";
+  sep = ' ';
+  if (z > 13) {
+    for (size_t did = 0; did < _idxs.size(); did++) {
+      const auto& idx = _idxs[did].second;
+
+      const auto& mgroups = idx.getMetaGroups(bbox);
+      for (const auto& mgroup : mgroups) {
+        json << sep;
+        sep = ',';
+        printMetaGroup(mgroup, did, z < 15, &json);
+      }
+    }
+  }
+
   json << "]}";
 
   if (cb.size()) json << ")";
@@ -284,8 +302,13 @@ 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.sidStart
-         << ",\"t\":" << sugg->type << ",\"a\":[";
+  if (sugg->station >= 0) {
+    (*out) << "{\"i\":" << sugg->station + range.sidStart
+           << ",\"t\":" << sugg->type << ",\"a\":[";
+  } else {
+    (*out) << "{\"i\":" << -(-sugg->station + (int64_t)range.gidStart)
+           << ",\"t\":" << sugg->type << ",\"a\":[";
+  }
   char sep = ' ';
   for (const auto& p : projArrow) {
     (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
@@ -296,6 +319,28 @@ void StatServer::printSugg(const Suggestion* sugg, size_t did,
 }
 
 // _____________________________________________________________________________
+void StatServer::printMetaGroup(const MetaGroup* mg, size_t did, bool simple,
+                            std::ostream* out) const {
+  (*out) << "{\"i\":" << mg->osmid  << ",\"g\":[";
+  char sep = ' ';
+  if (simple) {
+    (*out) << sep << "[" << mg->centroid.getY() << ","
+           << mg->centroid.getX() << "]";
+  } else {
+    for (const auto& p : mg->llPoly.getOuter()) {
+      (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
+      sep = ',';
+    }
+  }
+  (*out) << "]";
+  bool sugg = mg->osmid == 1;// || mg->suggestions.size() > 0;
+
+  if (sugg) (*out) << ",\"s\":1";
+
+  (*out) << "}";
+}
+
+// _____________________________________________________________________________
 void StatServer::printGroup(const Group* group, size_t did, bool simple,
                             bool aggr, std::ostream* out) const {
   const auto& range = _idxs[did].first;
@@ -374,6 +419,15 @@ size_t StatServer::getDidBySuggid(size_t suggid) const {
 }
 
 // _____________________________________________________________________________
+size_t StatServer::getDidByMGid(size_t mgid) const {
+  for (size_t i = 0; i < _idxs.size(); i++) {
+    if (_idxs[i].second.getMetaGroup(mgid)) return i;
+  }
+
+  return 0;
+}
+
+// _____________________________________________________________________________
 size_t StatServer::getDidByGid(size_t gid) const {
   for (size_t i = 0; i < _idxs.size(); i++) {
     auto range = _idxs[i].first;
@@ -446,6 +500,81 @@ util::http::Answer StatServer::handleSearch(const Params& pars) const {
 }
 
 // _____________________________________________________________________________
+util::http::Answer StatServer::handleMGroupReq(const Params& pars) const {
+  if (pars.count("id") == 0 || pars.find("id")->second.empty())
+    throw std::invalid_argument("No ID specified.");
+  std::string cb;
+  if (pars.count("cb")) cb = pars.find("cb")->second.c_str();
+
+  size_t mgid = atol(pars.find("id")->second.c_str());
+
+  size_t did = getDidByMGid(mgid);
+
+  const auto& range = _idxs[did].first;
+  const auto& idx = _idxs[did].second;
+
+  const auto& mgroup = idx.getMetaGroup(mgid);
+
+  if (!mgroup) return util::http::Answer("404 Not Found", "Group not found.");
+
+  std::stringstream json;
+
+  json << std::setprecision(10);
+
+  auto centroid = mgroup->centroid;
+
+  if (cb.size()) json << cb << "(";
+  json << "{\"id\":" << mgid << ","
+       << "\"lat\":" << centroid.getY() << ","
+       << "\"lon\":" << centroid.getX() << ","
+       << "\"osmid\":" << mgid
+       << ",\"groups\":[";
+
+  char sep = ' ';
+  for (const auto& gid : mgroup->groups) {
+    json << sep;
+    sep = ',';
+    const auto& group = idx.getGroup(gid);
+    json << "{\"id\":" << gid + range.gidStart << ","
+         << "\"osmid\":" << group->osmid << ","
+        << "\"attrs\":{";
+
+    char sep = ' ';
+
+    for (const auto& par : group->attrs) {
+      json << sep;
+      sep = ',';
+      json << "\"" << util::jsonStringEscape(par.first) << "\":[";
+
+      char sep2 = ' ';
+      for (const auto& val : par.second) {
+        json << sep2;
+        sep2 = ',';
+        json << "\"" << util::jsonStringEscape(val) << "\"";
+      }
+      json << "]";
+    }
+
+    json << "}";
+    if (group->suggestions.size() > 0) json << ",\"s\":1";
+    if (group->attrErrs.size()) json << ",\"e\":" << group->attrErrs.size();
+
+    json << "}";
+  }
+
+  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.");
@@ -468,9 +597,13 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
 
   json << std::setprecision(10);
 
+  auto centroid = group->centroid;
+
   if (cb.size()) json << cb << "(";
   json << "{\"id\":" << gid << ","
        << "\"osmid\":" << group->osmid << ","
+       << "\"lat\":" << centroid.getY() << ","
+       << "\"lon\":" << centroid.getX() << ","
        << "\"attrs\":{";
 
   char sep = ' ';
@@ -573,6 +706,12 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
     } else if (sugg->type == 8) {
       json << seper << "{\"type\":8,\"attr\":\"" << sugg->attrErrName << "\""
            << "}";
+    } else if (sugg->type == 9) {
+      json << seper << "{\"type\":9,\"target_gid\":" << sugg->target_gid << ",\"target_osm_rel_id\":" << sugg->target_osm_rel_id
+           << "}";
+    } else if (sugg->type == 10) {
+      json << seper << "{\"type\":10,\"target_gid\":" << sugg->target_gid << ",\"target_osm_rel_id\":" << sugg->target_osm_rel_id
+           << "}";
     } else {
       json << seper << "{\"type\":" << sugg->type << "}";
     }
@@ -713,6 +852,20 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
     } else if (sugg->type == 8) {
       json << seper << "{\"type\":8,\"attr\":\"" << sugg->attrErrName << "\""
            << "}";
+    } else if (sugg->type == 9) {
+      json << seper
+           << "{\"type\":9,\"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 == 10) {
+      json << seper
+           << "{\"type\":10,\"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 {
       json << seper << "{\"type\":" << sugg->type << "}";
     }

src/osmfixer/server/StatServer.h

@@ -31,15 +31,18 @@ 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 handleMGroupReq(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, bool aggr, std::ostream* out) const;
   void printSugg(const Suggestion* stat, size_t did, std::ostream* out) const;
+  void printMetaGroup(const MetaGroup* stat, size_t did, bool simple, std::ostream* out) const;
 
   size_t getDidBySid(size_t sid) const;
   size_t getDidBySuggid(size_t suggid) const;
   size_t getDidByGid(size_t gid) const;
+  size_t getDidByMGid(size_t mgid) const;
 
   const std::vector<std::pair<IdRange, osmfixer::StatIdx>>& _idxs;
   const SearchIdx& _searchIdx;

web/script.js

@@ -5,13 +5,16 @@ var stCols = ['#78f378', '#0000c3', 'red'];
 
 var osmUrl = "//www.openstreetmap.org/";
 
-var grIdx, stIdx, selectedRes, prevSearch, delayTimer;
+var grIdx, mGrIdx, stIdx, selectedRes, prevSearch, delayTimer;
 
 var reqs = {};
 
 var openedGr = -1;
+var openedMGr = -1;
 var openedSt = -1;
 
+
+// station sugg messages
 var sgMvOrNew = "Move into a <span class='grouplink' onmouseover='grHl(${tid})' onmouseout='grUnHl(${tid})'>new relation</span> <tt>public_transport=stop_area</tt>.";
 var sgMvOrEx = "Move into relation <a onmouseover='grHl(${tid})' onmouseout='grUnHl(${tid})' href=\"" + osmUrl + "relation/${toid}\" target=\"_blank\">${toid}</a>.";
 var sgMvRelNew = "Move from relation <a onmouseover='grHl(${oid})' onmouseout='grUnHl(${oid})' href=\"" + osmUrl + "relation/${ooid}\" target=\"_blank\">${ooid}</a> into a <span class='grouplink' onmouseover='grHl(${tid})' onmouseout='grUnHl(${tid})'>new relation</span> <tt>public_transport=stop_area</tt>.";
@@ -20,8 +23,19 @@ var sgMvOutRel = "Move out of relation <a onmouseover='grHl(${oid})' onmouseout=
 var sgFixAttr = "Fix attribute <tt>${attr}</tt>.";
 var sgAddName = "Consider adding a <tt><a target='_blank' href='https://wiki.openstreetmap.org/wiki/Key:name'>name</a></tt> attribute.";
 var sgAttrTr = "Attribute <tt>${attr}</tt> seems to be a track number. Use <tt>ref</tt> for this and set <tt>${attr}</tt> to the station name.";
+var sgMergeRel = "Merge parent relation <a onmouseover='grHl(${oid})' onmouseout='grUnHl(${oid})' href=\"" + osmUrl + "relation/${ooid}\" target=\"_blank\">${ooid}</a> with relation <a onmouseover='grHl(${tid})' onmouseout='grUnHl(${tid})' href=\"" + osmUrl + "relation/${toid}\" target=\"_blank\">${toid}</a>, or move them into a new relation <tt>public_transport=stop_area_group</tt>";
+var sgMergeMetaGr = "Move parent relation <a onmouseover='grHl(${oid})' onmouseout='grUnHl(${oid})' href=\"" + osmUrl + "relation/${ooid}\" target=\"_blank\">${ooid}</a> into meta <tt>public_transport=stop_area_group</tt> relation <a onmouseover='mGrHl(${tid})' onmouseout='mGrUnHl(${tid})' href=\"" + osmUrl + "relation/${toid}\" target=\"_blank\">${toid}</a>";
+
+var suggsMsg = [sgMvOrNew, sgMvOrEx, sgMvRelNew, sgMvRelRel, sgMvOutRel, sgFixAttr, sgAddName, sgAttrTr, sgMergeRel, sgMergeMetaGr];
 
-var suggsMsg = [sgMvOrNew, sgMvOrEx, sgMvRelNew, sgMvRelRel, sgMvOutRel, sgFixAttr, sgAddName, sgAttrTr];
+// group sugg messages
+var sgGrFixAttr = "Fix attribute <tt>${attr}</tt>.";
+var sgGrAddName = "Consider adding a <tt><a target='_blank' href='https://wiki.openstreetmap.org/wiki/Key:name'>name</a></tt> attribute.";
+var sgGrAttrTr = "Attribute <tt>${attr}</tt> seems to be a track number. Use <tt>ref</tt> for this and set <tt>${attr}</tt> to the station name.";
+var sgGrMergeRel = "Merge with relation <a onmouseover='grHl(${tid})' onmouseout='grUnHl(${tid})' href=\"" + osmUrl + "relation/${toid}\" target=\"_blank\">${toid}</a>, or move both into a new relation <tt>public_transport=stop_area_group</tt>";
+var sgGrMergeMeta = "Move relation into <tt>public_transport=stop_area_group</tt> relation <a onmouseover='mGrHl(${tid})' onmouseout='mGrUnHl(${tid})' href=\"" + osmUrl + "relation/${toid}\" target=\"_blank\">${toid}</a>";
+
+var groupSuggMsg = [sgGrFixAttr, sgGrAddName, sgGrAttrTr, sgGrMergeRel, sgGrMergeMeta];
 
 function $(a){return a[0] == "#" ? document.getElementById(a.substr(1)) : a[0] == "." ? document.getElementsByClassName(a.substr(1)) : document.getElementsByTagName(a)}
 function $$(t){return document.createElement(t) }
@@ -77,7 +91,7 @@ function marker(stat, z) {
     }
 }
 
-function poly(group, z) {
+function poly(group, z, dotted) {
     var col = group.e ? 'red' : group.s ? '#0000c3' : '#85f385';
     var style = {
         color: col,
@@ -86,6 +100,14 @@ function poly(group, z) {
         fillOpacity: 0.2,
         id: group.i
     };
+    if (dotted) {
+        var col = group.e ? 'red' : group.s ? '#0000c3' : '#a3b750';
+        style.dashArray = '8, 8';
+        style.fillOpacity = 0.15;
+        style.color = col;
+        style.fillColor = col;
+        style.weight = 2;
+    }
     if (z < 16) {
         style.weight = 11;
         style.opacity = 0.5;
@@ -197,7 +219,7 @@ function rndrSt(stat) {
 
 function openSt(id) {req("s", "/stat?id=" + id, function(c) {rndrSt(c)});}
 
-function rndrGr(grp, ll) {
+function rndrGr(grp) {
     openedGr = grp.id;
     var attrrows = {};
     grHl(grp.id);
@@ -269,6 +291,28 @@ function rndrGr(grp, ll) {
         row.childNodes[1].appendChild(info);
     }
 
+    var suggList = $$('ul');
+
+    if (grp.su.length) {
+        var a = $$('span');
+        addCl(a, "sugtit");
+        a.innerHTML = "Suggestions";
+        suggD.appendChild(a);
+    }
+
+    suggD.appendChild(suggList);
+    var mergeGroup = false;
+
+    for (var i = 0; i < grp.su.length; i++) {
+        var sg = grp.su[i];
+        var sgDiv = $$('li');
+
+        if (sg.type == 9 || sg.type == 10) mergeGroup = true;
+
+        sgDiv.innerHTML = tmpl(groupSuggMsg[sg.type - 6], {"attr" : sg.attr, "tid" : sg.target_gid, "ooid" : sg.orig_osm_rel_id, "toid" : sg.target_osm_rel_id, "oid" : sg.orig_gid});
+        suggList.appendChild(sgDiv);
+    }
+
     con.appendChild(newMembers);
     if (grp.osmid != 1) con.appendChild(oldMembers);
 
@@ -286,43 +330,70 @@ function rndrGr(grp, ll) {
         if (grp.osmid == 1 || stat.orig_group != grp.id) newMembers.appendChild(row);
         else {
             oldMembers.appendChild(row);
-            if (stat.group != grp.id) addCl(row, "del-stat");
+            if (stat.group != grp.id && !mergeGroup) addCl(row, "del-stat");
         }
     }
 
-    var suggList = $$('ul');
+    con.appendChild(suggD);
 
-    if (grp.su.length) {
-        var a = $$('span');
-        addCl(a, "sugtit");
-        a.innerHTML = "Suggestions";
-        suggD.appendChild(a);
-    }
+    L.popup({opacity: 0.8})
+        .setLatLng(grp)
+        .setContent(con)
+        .openOn(map)
+        .on('remove', function() {if (openedGr == grp.id) {openedGr = -1; grUnHl(grp.id)}});
+}
 
-    suggD.appendChild(suggList);
+function rndrMGr(grp) {
+    openedMGr = grp.id;
+    mGrHl(grp.id);
 
-    for (var i = 0; i < grp.su.length; i++) {
-        var sugg = grp.su[i];
-        var suggDiv = $$('li');
+    var con = $$('div');
+    con.setAttribute("id", "nav");
 
-        if (sugg.type == 6) suggDiv.innerHTML = "Fix attribute <tt>" + sugg.attr + "</tt>.";
-        else if (sugg.type == 7) suggDiv.innerHTML = "Consider adding a <tt><a target='_blank' href='https://wiki.openstreetmap.org/wiki/Key:name'>name</a></tt> attribute.";
-        else if (sugg.type == 8) suggDiv.innerHTML = "Attribute <tt>" + sugg.attr + "</tt> seems to be a track number. Use <tt>ref</tt> for this and set <tt>" + sugg.attr + "</tt> to the station name.";
+    var oldMembers = $$('div');
+    oldMembers.setAttribute("id", "group-stations-old")
+    oldMembers.innerHTML = "<span class='oldmemberstit'>Members</span>";
 
-        suggList.appendChild(suggDiv);
-    }
+    con.innerHTML = "OSM relation <a target='_blank' href='https://www.openstreetmap.org/relation/" + grp.osmid + "'>" + grp.osmid + " </a> (<tt>public_transport=stop_area_group</tt>)";
+    con.innerHTML += "<a class='ebut' target='_blank' href='https://www.openstreetmap.org/edit?relation=" + grp.osmid +"'>&#9998;</a>";
 
-    con.appendChild(suggD);
+    con.appendChild(oldMembers);
+
+    for (var key in grp.groups) {
+        var gr = grp.groups[key];
+        var row = $$('div');
+
+        row.innerHTML = "Relation <a onmouseover='grHl( " + gr.id + ")' onmouseout='grUnHl( " + gr.id + ")' target='_blank' href='" + osmUrl + "relations/" + gr.osmid + "'>" + gr.osmid + "</a>";
+        if (gr.attrs.name) row.innerHTML += " (<b>\"" + gr.attrs.name[0] + "\"</b>)";
+        row.style.backgroundColor = gr.e ? '#f58d8d' : gr.s ? '#b6b6e4' : '#c0f7c0';
+
+        oldMembers.appendChild(row);
+    }
 
     L.popup({opacity: 0.8})
-        .setLatLng(ll)
+        .setLatLng(grp)
         .setContent(con)
         .openOn(map)
-        .on('remove', function() {if (openedGr == grp.id) {openedGr = -1; grUnHl(grp.id)}});
+        .on('remove', function() {if (openedMGr == grp.id) {openedMGr = -1; mGrUnHl(grp.id)}});
+}
+
+function openGr(id) {
+    req("g", "/group?id=" + id, function(c) {rndrGr(c)});
+}
+
+function openMGr(id) {
+    req("g", "/mgroup?id=" + id, function(c) {rndrMGr(c)});
+}
+
+function mGrHl(id) {
+    !mGrIdx[id] || mGrIdx[id].setStyle({'weight': 6, 'color': "#eecc00"});
 }
 
-function openGr(id, ll) {
-    req("g", "/group?id=" + id, function(c) {rndrGr(c, ll)});
+function mGrUnHl(id) {
+    !mGrIdx[id] || mGrIdx[id].setStyle({
+        'weight': 2,
+        'color': mGrIdx[id].options["fillColor"]
+    });
 }
 
 function grHl(id) {
@@ -448,6 +519,7 @@ function render() {
             function(re) {
                 l.clearLayers();
                 grIdx = {};
+                mGrIdx = {};
                 stIdx = {};
 
                 var stats = [];
@@ -457,7 +529,12 @@ function render() {
 
                 var groups = [];
                 for (var i = 0; i < re.groups.length; i++) {
-                    grIdx[re.groups[i].i] = groups[groups.push(poly(re.groups[i], map.getZoom())) - 1];;
+                    grIdx[re.groups[i].i] = groups[groups.push(poly(re.groups[i], map.getZoom())) - 1];
+                }
+
+                var mgroups = [];
+                for (var i = 0; i < re.mgroups.length; i++) {
+                    mGrIdx[re.mgroups[i].i] = mgroups[mgroups.push(poly(re.mgroups[i], map.getZoom(), 1)) - 1];
                 }
 
                 var suggs = [];
@@ -466,6 +543,9 @@ function render() {
                 }
 
                 if (map.getZoom() > 13) {
+                    l.addLayer(L.featureGroup(mgroups).on('click', function(a) {
+                        openMGr(a.layer.options.id, a.layer.getBounds().getCenter());
+                    }));
                     l.addLayer(L.featureGroup(groups).on('click', function(a) {
                         openGr(a.layer.options.id, a.layer.getBounds().getCenter());
                     }));
@@ -477,11 +557,13 @@ function render() {
 
                 if (map.getZoom() > 15) {
                     l.addLayer(L.featureGroup(suggs).on('click', function(a) {
-                        openSt(a.layer.options.id);
+                        if (a.layer.options.id < 0) openGr(-a.layer.options.id);
+                        else openSt(a.layer.options.id);
                     }));
                 }
 
                 grHl(openedGr);
+                mGrHl(openedMGr);
                 stHl(openedSt);
             }
         )