some changes

src/osmfixer/index/StatIdx.cpp

@@ -68,8 +68,14 @@ void StatIdx::readFromFile(const std::string& path) {
       }
     }
 
+    if (geom.size() != 1 && util::geo::dist(geom.front(), geom.back()) > 1) {
+      // transform lines into polygons
+      geom = hull(geom, 2).getOuter();
+    }
+
     if (geom.size() > 1) geom = util::geo::simplify(geom, 0.5);
-    for (const auto& p : geom) latLngs.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
+    for (const auto& p : geom)
+      latLngs.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
 
     addStation(osmid, geom, latLngs, origGroup, group, attrs);
   }
@@ -87,13 +93,21 @@ void StatIdx::readFromFile(const std::string& path) {
 
     rec >> osmid;
 
+    std::string key;
+    std::getline(rec, key, '\t');
+    while (std::getline(rec, key, '\t')) {
+      std::string val;
+      std::getline(rec, val, '\t');
+      attrs[key].push_back(val);
+    }
+
     addGroup(osmid, attrs);
   }
 
   LOG(INFO) << "Done.";
 
   // third, parse attr errs
-  LOG(INFO) << "Parsing errors... ";
+  LOG(INFO) << "Parsing station errors... ";
   while (std::getline(f, line)) {
     // empty line is separator between blocks
     if (line.size() == 0) break;
@@ -102,7 +116,7 @@ void StatIdx::readFromFile(const std::string& path) {
     size_t id;
     std::string attr, otherAttr;
     double conf;
-    int64_t otherId;
+    int64_t otherIdRaw;
 
     rec >> id;
 
@@ -111,9 +125,48 @@ void StatIdx::readFromFile(const std::string& path) {
     std::getline(rec, otherAttr, '\t');
 
     rec >> conf;
-    rec >> otherId;
+    rec >> otherIdRaw;
 
-    _stations[id].attrErrs.push_back({attr, otherAttr, conf, otherId});
+    size_t otherId;
+    bool fromRel = false;
+
+    if (otherIdRaw < 0) fromRel = true;
+
+    otherId = labs(otherIdRaw);
+
+    _stations[id].attrErrs.push_back({attr, otherAttr, conf, otherId, fromRel});
+  }
+  LOG(INFO) << "Done.";
+
+  // fourth, parse attr errs in groups
+  LOG(INFO) << "Parsing group errors... ";
+  while (std::getline(f, line)) {
+    // empty line is separator between blocks
+    if (line.size() == 0) break;
+
+    std::stringstream rec(line);
+    size_t id;
+    std::string attr, otherAttr;
+    double conf;
+    int64_t otherIdRaw;
+
+    rec >> id;
+
+    std::getline(rec, attr, '\t');
+    std::getline(rec, attr, '\t');
+    std::getline(rec, otherAttr, '\t');
+
+    rec >> conf;
+    rec >> otherIdRaw;
+
+    size_t otherId;
+    bool fromRel = false;
+
+    if (otherIdRaw < 0) fromRel = true;
+
+    otherId = labs(otherIdRaw);
+
+    _groups[id].attrErrs.push_back({attr, otherAttr, conf, otherId, fromRel});
   }
   LOG(INFO) << "Done.";
 
@@ -175,24 +228,17 @@ void StatIdx::initGroups() {
     }
   }
 
+
   // build hull polygon
   for (size_t i = 0; i < _groups.size(); i++) {
     util::geo::MultiPoint<double> mp;
     for (size_t stid : _groups[i].polyStations) {
-      double rad = 11.0;
-      int n = 20;
-      for (int i = 0; i < n; i++) {
-        double x = rad * cos((2.0 * M_PI / static_cast<double>(n)) *
-                             static_cast<double>(i));
-        double y = rad * sin((2.0 * M_PI / static_cast<double>(n)) *
-                             static_cast<double>(i));
-
-        for (const auto& geom : _stations[stid].pos) {
-          mp.push_back(util::geo::DPoint(geom.getX() + x, geom.getY() + y));
-        }
+      for (const auto& geom : _stations[stid].pos) {
+        mp.push_back(util::geo::DPoint(geom.getX(), geom.getY()));
       }
     }
-    _groups[i].poly = util::geo::simplify(util::geo::convexHull(mp).getOuter(), 0.5);
+
+    _groups[i].poly = hull(mp, 11);
 
     for (auto p : _groups[i].poly.getOuter()) {
       _groups[i].llPoly.getOuter().push_back(
@@ -204,6 +250,28 @@ void StatIdx::initGroups() {
 }
 
 // _____________________________________________________________________________
+util::geo::Polygon<double> StatIdx::hull(
+    const util::geo::MultiPoint<double>& imp, double rad) const {
+  util::geo::MultiPoint<double> mp;
+  util::geo::Polygon<double> ret;
+  for (const auto& geom : imp) {
+    // double rad = 11.0;
+    int n = 20;
+    for (int i = 0; i < n; i++) {
+      double x = rad * cos((2.0 * M_PI / static_cast<double>(n)) *
+                           static_cast<double>(i));
+      double y = rad * sin((2.0 * M_PI / static_cast<double>(n)) *
+                           static_cast<double>(i));
+
+      mp.push_back(util::geo::DPoint(geom.getX() + x, geom.getY() + y));
+    }
+  }
+  ret = util::geo::simplify(util::geo::convexHull(mp).getOuter(), 0.5);
+
+  return ret;
+}
+
+// _____________________________________________________________________________
 void StatIdx::initIndex() {
   double gSize = 10000;
   _sgrid = util::geo::Grid<size_t, util::geo::Polygon, double>(gSize, gSize,
@@ -465,21 +533,80 @@ std::vector<osmfixer::Cluster> StatIdx::getHeatGridSugg(
 }
 // _____________________________________________________________________________
 void StatIdx::initSuggestions() {
+  // group suggestions
+  for (size_t i = 0; i < _groups.size(); i++) {
+    auto& group = _groups[i];
+
+    if (group.attrs.size() == 0) {
+      Suggestion sug;
+      sug.station = i;
+      sug.type = 7;
+      _suggestions.push_back(sug);
+      group.suggestions.push_back(_suggestions.size() - 1);
+    }
+
+    Suggestion sug;
+    sug.station = i;
+
+    std::set<std::pair<std::string, uint16_t>> suggested;
+    for (auto attrErr : group.attrErrs) {
+      if (!attrErr.fromRel) continue;
+
+      const auto otherGrp = getGroup(attrErr.otherId);
+      if (group.id == attrErr.otherId && attrErr.attr == attrErr.otherAttr) {
+        if (suggested.count({attrErr.attr, 8})) continue;
+        // fix track number as name
+        suggested.insert({attrErr.attr, 8});
+        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);
+        group.suggestions.push_back(_suggestions.size() - 1);
+      } else if (otherGrp->osmid == group.osmid) {
+        if (suggested.count({attrErr.attr, 6})) continue;
+        // fix attributes
+        suggested.insert({attrErr.attr, 6});
+        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);
+        group.suggestions.push_back(_suggestions.size() - 1);
+      }
+    }
+  }
+
+  // station suggestions
   for (size_t i = 0; i < _stations.size(); i++) {
     auto& stat = _stations[i];
+
+    if (stat.attrs.size() == 0) {
+      Suggestion sug;
+      sug.station = i;
+      sug.type = 7;
+      _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;
       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) {
           // move orphan into new group
           sug.type = 1;
           sug.target_gid = stat.group;
 
-          // sug.arrow = getGroupArrow(i, stat.group);
-
           _suggestions.push_back(sug);
           stat.suggestions.push_back(_suggestions.size() - 1);
 
@@ -539,21 +666,42 @@ void StatIdx::initSuggestions() {
           stat.suggestions.push_back(_suggestions.size() - 1);
         }
       }
+    }
 
-      for (auto attrErr : stat.attrErrs) {
-        const auto otherStat = getStation(attrErr.otherId);
-        if (otherStat->osmid == stat.osmid) {
-          // 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);
-        }
+    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

@@ -19,7 +19,8 @@ struct AttrErr {
   std::string attr;
   std::string otherAttr;
   double conf;
-  int64_t otherId;
+  size_t otherId;
+  bool fromRel;
 };
 
 struct Suggestion {
@@ -53,6 +54,8 @@ struct Group {
   OsmAttrs attrs;
   std::vector<size_t> stations;
   std::vector<size_t> polyStations;
+  std::vector<AttrErr> attrErrs;
+  std::vector<size_t> suggestions;
 };
 
 struct Cluster {
@@ -102,6 +105,8 @@ class StatIdx {
 
   util::geo::DLine getGroupArrow(size_t stat, const util::geo::DPoint& p) const;
 
+  util::geo::Polygon<double> hull(const util::geo::MultiPoint<double>& imp, double rad) const;
+
   std::vector<Station> _stations;
   std::vector<Group> _groups;
   std::vector<Suggestion> _suggestions;

src/osmfixer/server/StatServer.cpp

@@ -181,7 +181,6 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
   if (z < 9) p = 2;
   if (z < 7) p = 1;
 
-
   std::stringstream json;
 
   json << std::fixed << std::setprecision(p);
@@ -243,7 +242,6 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
 // _____________________________________________________________________________
 void StatServer::printStation(const Station* stat, size_t did, bool simple,
                               std::ostream* out) const {
-  const auto& idx = _idxs[did].second;
   const auto& range = _idxs[did].first;
 
   (*out) << "{\"i\":" << stat->id + range.sidStart << ",\"g\":[";
@@ -261,7 +259,7 @@ void StatServer::printStation(const Station* stat, size_t did, bool simple,
 
   (*out) << "]";
 
-  if (stat->origGroup != stat->group || idx.getGroup(stat->group)->osmid == 1)
+  if (stat->suggestions.size() > 0)
     (*out) << ",\"s\":1";
 
   if (stat->attrErrs.size())
@@ -309,6 +307,12 @@ 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->attrErrs.size())
+    (*out) << ",\"e\":" << group->attrErrs.size();
   (*out) << "}";
 }
 
@@ -411,7 +415,39 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
     json << "]";
   }
 
-  json << "},\"stations\":[";
+  json << "},\"attrerrs\":[";
+
+  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;
+
+    json << sep;
+    sep = ',';
+    json << "{";
+    json << "\"attr\":[\"" << err.attr << "\",\"" << group->attrs.at(err.attr)[0]
+         << "\"]";
+    json << ",\"conf\":" << err.conf;
+
+    if (err.fromRel) {
+      const auto otherGroup = idx.getGroup(err.otherId);
+      json << ",\"other_attr\":[\"" << err.otherAttr << "\",\""
+           << otherGroup->attrs.at(err.otherAttr)[0] << "\"]";
+      json << ",\"other_grp\":" << err.otherId + range.gidStart;
+      json << ",\"other_osmid\":" << otherGroup->osmid;
+    } else {
+      const auto otherStat = idx.getStation(err.otherId);
+      json << ",\"other_attr\":[\"" << err.otherAttr << "\",\""
+           << otherStat->attrs.at(err.otherAttr)[0] << "\"]";
+      json << ",\"other\":" << err.otherId + range.sidStart;
+      json << ",\"other_osmid\":" << otherStat->osmid;
+    }
+    json << "}";
+  }
+
+  json << "]";
+
+  json << ",\"stations\":[";
 
   sep = ' ';
   for (const auto& sid : group->stations) {
@@ -439,11 +475,39 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
       }
       json << "]";
     }
-    json << "}}";
+    json << "}";
+    if (stat->suggestions.size() > 0)
+      json << ",\"s\":1";
+
+    if (stat->attrErrs.size())
+      json << ",\"e\":" << stat->attrErrs.size();
+    json << "}";
   }
 
   json << "]";
 
+  json << ",\"su\":[";
+
+  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 = ',';
+    }
+
+  json << "]";
+
   json << "}";
 
   if (cb.size()) json << ")";
@@ -506,17 +570,29 @@ 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;
     json << sep;
     sep = ',';
-    const auto& otherStat = idx.getStation(err.otherId);
     json << "{";
     json << "\"attr\":[\"" << err.attr << "\",\"" << stat->attrs.at(err.attr)[0]
          << "\"]";
-    json << ",\"other_attr\":[\"" << err.otherAttr << "\",\""
-         << otherStat->attrs.at(err.otherAttr)[0] << "\"]";
     json << ",\"conf\":" << err.conf;
-    json << ",\"other\":" << err.otherId + range.sidStart;
-    json << ",\"other_osmid\":" << otherStat->osmid;
+
+    if (err.fromRel) {
+      const auto otherGroup = idx.getGroup(err.otherId);
+      json << ",\"other_attr\":[\"" << err.otherAttr << "\",\""
+           << otherGroup->attrs.at(err.otherAttr)[0] << "\"]";
+      json << ",\"other_grp\":" << err.otherId + range.gidStart;
+      json << ",\"other_osmid\":" << otherGroup->osmid;
+    } else {
+      const auto otherStat = idx.getStation(err.otherId);
+      json << ",\"other_attr\":[\"" << err.otherAttr << "\",\""
+           << otherStat->attrs.at(err.otherAttr)[0] << "\"]";
+      json << ",\"other\":" << err.otherId + range.sidStart;
+      json << ",\"other_osmid\":" << otherStat->osmid;
+    }
+
     json << "}";
   }
 
@@ -524,54 +600,45 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
 
   json << ",\"su\":[";
 
-  char seper = ' ';
+  std::string seper = "";
 
-  // suggestions
-  if (stat->group != stat->origGroup || idx.getGroup(stat->group)->osmid == 1) {
-    if (idx.getGroup(stat->origGroup)->osmid < 2) {
-      if (idx.getGroup(stat->group)->osmid == 1) {
-        json << "{\"type\": 1, \"target_gid\":" << stat->group + range.gidStart
+  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
              << "}";
-        seper = ',';
-      } else if (idx.getGroup(stat->group)->osmid > 1) {
-        json << "{\"type\": 2, \"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
              << "}";
-        seper = ',';
-      }
-    } else {
-      if (idx.getGroup(stat->group)->osmid == 1 &&
-          idx.getGroup(stat->group)->stations.size() > 1) {
-        json << "{\"type\": 3,\"orig_gid\":" << stat->origGroup + range.gidStart
+      } 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 << "}";
-        seper = ',';
-      } else if (idx.getGroup(stat->group)->osmid > 1) {
-        json << "{\"type\": 4,\"orig_gid\":" << stat->origGroup + 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 << "}";
-        seper = ',';
-      } else {
-        json << "{\"type\": 5,\"orig_gid\":" << stat->origGroup + 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
              << "}";
-        seper = ',';
+      } 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 << "}";
       }
-    }
-  }
-
-  for (const auto& attrErr : stat->attrErrs) {
-    const auto otherStat = idx.getStation(attrErr.otherId);
-    if (otherStat->osmid == stat->osmid) {
-      // fix attributes
-      json << seper << "{\"type\": 6,\"attr\":\"" << attrErr.attr << "\""
-           << "}";
       seper = ',';
     }
-  }
 
   json << "]";