polygon support

src/osmfixer/index/StatIdx.cpp

@@ -30,27 +30,48 @@ void StatIdx::readFromFile(const std::string& path) {
     if (line.size() == 0) break;
 
     std::stringstream rec(line);
-    size_t osmid, origGroup, group;
-    double lat, lng;
+    int64_t osmid, origGroup, group;
+    double lat = 0, lng = 0;
     OsmAttrs attrs;
 
     rec >> osmid;
-    rec >> lat;
-    rec >> lng;
     rec >> origGroup;
     rec >> group;
 
+    util::geo::DLine geom;
+    util::geo::DLine latLngs;
+
     std::string temp;
+    std::string key, val;
+    uint8_t sw = 0;
     std::getline(rec, temp, '\t');
     while (std::getline(rec, temp, '\t')) {
-      std::string key, val;
-      key = temp;
-      std::getline(rec, temp, '\t');
-      val = temp;
-      attrs[key].push_back(val);
+      if (sw == 2) {
+        std::getline(rec, val, '\t');
+        attrs[temp].push_back(val);
+      } else {
+        try {
+          double a = std::stod(temp);
+          if (sw == 1) {
+            lat = a;
+            geom.push_back(util::geo::latLngToWebMerc<double>(lat, lng));
+            sw = 0;
+          } else if (sw == 0) {
+            lng = a;
+            sw = 1;
+          }
+        } catch (std::invalid_argument) {
+          sw = 2;
+          std::getline(rec, val, '\t');
+          attrs[temp].push_back(val);
+        }
+      }
     }
 
-    addStation(osmid, lat, lng, origGroup, group, attrs);
+    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()));
+
+    addStation(osmid, geom, latLngs, origGroup, group, attrs);
   }
   LOG(INFO) << "Done.";
 
@@ -61,7 +82,7 @@ void StatIdx::readFromFile(const std::string& path) {
     if (line.size() == 0) break;
 
     std::stringstream rec(line);
-    size_t osmid;
+    int64_t osmid;
     OsmAttrs attrs;
 
     rec >> osmid;
@@ -81,7 +102,7 @@ void StatIdx::readFromFile(const std::string& path) {
     size_t id;
     std::string attr, otherAttr;
     double conf;
-    size_t otherId;
+    int64_t otherId;
 
     rec >> id;
 
@@ -105,23 +126,23 @@ void StatIdx::readFromFile(const std::string& path) {
 }
 
 // _____________________________________________________________________________
-void StatIdx::addStation(size_t osmid, double lat, double lng, size_t origGroup,
+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) {
-  auto point = util::geo::latLngToWebMerc<double>(lat, lng);
-
-  _stations.emplace_back(
-      Station{_stations.size(),
-              osmid,
-              origGroup,
-              group,
-              point,
-              util::geo::webMercToLatLng<double>(point.getX(), point.getY()),
-              attrs,
-              {},
-              {}});
+  auto centroid = util::geo::centroid(latLngs);
+  _stations.emplace_back(Station{_stations.size(),
+                                 osmid,
+                                 origGroup,
+                                 group,
+                                 centroid,
+                                 geom,
+                                 latLngs,
+                                 attrs,
+                                 {},
+                                 {}});
 
   // extend bounding box
-  _bbox = util::geo::extendBox(point, _bbox);
+  for (const auto& point : geom) _bbox = util::geo::extendBox(point, _bbox);
 }
 
 // _____________________________________________________________________________
@@ -166,19 +187,27 @@ void StatIdx::initGroups() {
         double y = rad * sin((2.0 * M_PI / static_cast<double>(n)) *
                              static_cast<double>(i));
 
-        mp.push_back(util::geo::DPoint(_stations[stid].pos.getX() + x,
-                                       _stations[stid].pos.getY() + y));
+        for (const auto& geom : _stations[stid].pos) {
+          mp.push_back(util::geo::DPoint(geom.getX() + x, geom.getY() + y));
+        }
       }
     }
-    _groups[i].poly = util::geo::convexHull(mp);
+    _groups[i].poly = util::geo::simplify(util::geo::convexHull(mp).getOuter(), 0.5);
+
+    for (auto p : _groups[i].poly.getOuter()) {
+      _groups[i].llPoly.getOuter().push_back(
+          util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
+    }
+
+    _groups[i].centroid = util::geo::centroid(_groups[i].llPoly);
   }
 }
 
 // _____________________________________________________________________________
 void StatIdx::initIndex() {
   double gSize = 10000;
-  _sgrid = util::geo::Grid<size_t, util::geo::Point, double>(gSize, gSize,
-                                                             _bbox, false);
+  _sgrid = util::geo::Grid<size_t, util::geo::Polygon, double>(gSize, gSize,
+                                                               _bbox, false);
   _ggrid = 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,
@@ -194,18 +223,25 @@ void StatIdx::initIndex() {
   _heatGridsErr.resize(10);
 
   for (size_t i = 0; i < 10; i++) {
-    _heatGridsOk[i] = (util::geo::Grid<osmfixer::Cluster, util::geo::Point, double>(
-        5000, 5000, _bbox, false));
-    _heatGridsSugg[i] = (util::geo::Grid<osmfixer::Cluster, util::geo::Point, double>(
-        5000, 5000, _bbox, false));
-    _heatGridsErr[i] = (util::geo::Grid<osmfixer::Cluster, util::geo::Point, double>(
-        5000, 5000, _bbox, false));
+    _heatGridsOk[i] =
+        (util::geo::Grid<osmfixer::Cluster, util::geo::Point, double>(
+            5000, 5000, _bbox, false));
+    _heatGridsSugg[i] =
+        (util::geo::Grid<osmfixer::Cluster, util::geo::Point, double>(
+            5000, 5000, _bbox, false));
+    _heatGridsErr[i] =
+        (util::geo::Grid<osmfixer::Cluster, util::geo::Point, double>(
+            5000, 5000, _bbox, false));
     int step = 2000 * (i + 1);
 
     for (size_t x = 1; x * step < (_sgrid.getXWidth() * gSize); x++) {
       for (size_t y = 1; y * step < (_sgrid.getYHeight() * gSize); y++) {
         std::set<size_t> tmp;
-        auto reqBox = util::geo::DBox({_bbox.getLowerLeft().getX() + (x - 1) * step, _bbox.getLowerLeft().getY() + (y - 1) * step}, {_bbox.getLowerLeft().getX() + x * step, _bbox.getLowerLeft().getY() + y * step});
+        auto reqBox =
+            util::geo::DBox({_bbox.getLowerLeft().getX() + (x - 1) * step,
+                             _bbox.getLowerLeft().getY() + (y - 1) * step},
+                            {_bbox.getLowerLeft().getX() + x * step,
+                             _bbox.getLowerLeft().getY() + y * step});
         _sgrid.get(reqBox, &tmp);
 
         size_t countOk = 0;
@@ -223,22 +259,28 @@ void StatIdx::initIndex() {
         for (auto j : tmp) {
           const auto& stat = _stations[j];
           if (stat.suggestions.size() == 0 && stat.attrErrs.size() == 0) {
-            if (util::geo::contains(stat.pos, reqBox)) {
-              countOk++;
-              avgXOk += stat.pos.getX();
-              avgYOk += stat.pos.getY();
+            for (const auto& pos : stat.pos) {
+              if (util::geo::contains(pos, reqBox)) {
+                countOk++;
+                avgXOk += pos.getX();
+                avgYOk += pos.getY();
+              }
             }
           } else if (stat.suggestions.size() > 0 && stat.attrErrs.size() == 0) {
-            if (util::geo::contains(stat.pos, reqBox)) {
-              countSugg++;
-              avgXSugg += stat.pos.getX();
-              avgYSugg += stat.pos.getY();
+            for (const auto& pos : stat.pos) {
+              if (util::geo::contains(pos, reqBox)) {
+                countSugg++;
+                avgXSugg += pos.getX();
+                avgYSugg += pos.getY();
+              }
             }
           } else if (stat.attrErrs.size() > 0) {
-            if (util::geo::contains(stat.pos, reqBox)) {
-              countErr++;
-              avgXErr += stat.pos.getX();
-              avgYErr += stat.pos.getY();
+            for (const auto& pos : stat.pos) {
+              if (util::geo::contains(pos, reqBox)) {
+                countErr++;
+                avgXErr += pos.getX();
+                avgYErr += pos.getY();
+              }
             }
           }
         }
@@ -248,7 +290,8 @@ void StatIdx::initIndex() {
           avgYOk /= countOk;
           auto ll = util::geo::webMercToLatLng<double>(avgXOk, avgYOk);
 
-          _heatGridsOk[i].add({avgXOk, avgYOk}, Cluster{{avgXOk, avgYOk}, ll, countOk});
+          _heatGridsOk[i].add({avgXOk, avgYOk},
+                              Cluster{{avgXOk, avgYOk}, ll, countOk});
         }
 
         if (countSugg != 0) {
@@ -256,7 +299,8 @@ void StatIdx::initIndex() {
           avgYSugg /= countSugg;
           auto ll = util::geo::webMercToLatLng<double>(avgXSugg, avgYSugg);
 
-          _heatGridsSugg[i].add({avgXSugg, avgYSugg}, Cluster{{avgXSugg, avgYSugg}, ll, countSugg});
+          _heatGridsSugg[i].add({avgXSugg, avgYSugg},
+                                Cluster{{avgXSugg, avgYSugg}, ll, countSugg});
         }
 
         if (countErr != 0) {
@@ -264,7 +308,8 @@ void StatIdx::initIndex() {
           avgYErr /= countErr;
           auto ll = util::geo::webMercToLatLng<double>(avgXErr, avgYErr);
 
-          _heatGridsErr[i].add({avgXErr, avgYErr}, Cluster{{avgXErr, avgYErr}, ll, countErr});
+          _heatGridsErr[i].add({avgXErr, avgYErr},
+                               Cluster{{avgXErr, avgYErr}, ll, countErr});
         }
       }
     }
@@ -305,7 +350,7 @@ std::vector<const Group*> StatIdx::getGroups(const util::geo::DBox bbox) const {
   _ggrid.get(reqBox, &tmp);
 
   for (auto i : tmp) {
-    // if (util::geo::intersects(_groups[i].poly, reqBox))
+    if (util::geo::intersects(_groups[i].poly, reqBox))
       ret.push_back(&_groups[i]);
   }
 
@@ -326,8 +371,10 @@ std::vector<const Station*> StatIdx::getStations(
   _sgrid.get(reqBox, &tmp);
 
   for (auto i : tmp) {
-    if (util::geo::contains(_stations[i].pos, reqBox))
+    if (util::geo::intersects(util::geo::Polygon<double>(_stations[i].pos),
+                              reqBox)) {
       ret.push_back(&_stations[i]);
+    }
   }
 
   return ret;
@@ -340,8 +387,8 @@ const Station* StatIdx::getStation(size_t id) const {
 }
 
 // _____________________________________________________________________________
-std::vector<osmfixer::Cluster> StatIdx::getHeatGridErr(const util::geo::DBox bbox,
-                                                    size_t z) const {
+std::vector<osmfixer::Cluster> StatIdx::getHeatGridErr(
+    const util::geo::DBox bbox, size_t z) const {
   auto ll = util::geo::latLngToWebMerc<double>(bbox.getLowerLeft().getX(),
                                                bbox.getLowerLeft().getY());
   auto ur = util::geo::latLngToWebMerc<double>(bbox.getUpperRight().getX(),
@@ -366,8 +413,8 @@ std::vector<osmfixer::Cluster> StatIdx::getHeatGridErr(const util::geo::DBox bbo
 }
 
 // _____________________________________________________________________________
-std::vector<osmfixer::Cluster> StatIdx::getHeatGridOk(const util::geo::DBox bbox,
-                                                    size_t z) const {
+std::vector<osmfixer::Cluster> StatIdx::getHeatGridOk(
+    const util::geo::DBox bbox, size_t z) const {
   auto ll = util::geo::latLngToWebMerc<double>(bbox.getLowerLeft().getX(),
                                                bbox.getLowerLeft().getY());
   auto ur = util::geo::latLngToWebMerc<double>(bbox.getUpperRight().getX(),
@@ -392,8 +439,8 @@ std::vector<osmfixer::Cluster> StatIdx::getHeatGridOk(const util::geo::DBox bbox
 }
 
 // _____________________________________________________________________________
-std::vector<osmfixer::Cluster> StatIdx::getHeatGridSugg(const util::geo::DBox bbox,
-                                                    size_t z) const {
+std::vector<osmfixer::Cluster> StatIdx::getHeatGridSugg(
+    const util::geo::DBox bbox, size_t z) const {
   auto ll = util::geo::latLngToWebMerc<double>(bbox.getLowerLeft().getX(),
                                                bbox.getLowerLeft().getY());
   auto ur = util::geo::latLngToWebMerc<double>(bbox.getUpperRight().getX(),
@@ -423,7 +470,8 @@ void StatIdx::initSuggestions() {
     if (stat.group != stat.origGroup || getGroup(stat.group)->osmid == 1) {
       Suggestion sug;
       sug.station = i;
-      sug.arrow = util::geo::DLine{stat.pos, stat.pos};
+      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
@@ -481,7 +529,7 @@ void StatIdx::initSuggestions() {
           sug.target_gid = stat.group;
           sug.target_osm_rel_id = getGroup(stat.group)->osmid;
 
-          auto b = stat.pos;
+          auto b = util::geo::centroid(stat.pos);
           b.setX(b.getX() + 50);
           b.setY(b.getY() + 50);
 
@@ -512,8 +560,9 @@ void StatIdx::initSuggestions() {
 }
 
 // _____________________________________________________________________________
-util::geo::DLine StatIdx::getGroupArrow(size_t stat, const util::geo::DPoint& b) const {
-  auto a = getStation(stat)->pos;
+util::geo::DLine StatIdx::getGroupArrow(size_t stat,
+                                        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;
@@ -528,7 +577,6 @@ util::geo::DLine StatIdx::getGroupArrow(size_t stat, const util::geo::DPoint& b)
   if (util::geo::dist(a, bb) < 20) {
     line = {a, bb};
   } else {
-
     int side = rand() % 2;
     if (!side) side = -1;
 
@@ -536,9 +584,9 @@ util::geo::DLine StatIdx::getGroupArrow(size_t stat, const util::geo::DPoint& b)
     auto rot2 = util::geo::rotate(util::geo::DLine{a, bb}, -20 * side, bb);
     auto rot3 = util::geo::rotate(util::geo::DLine{a, bb}, -120 * side, bb);
 
-    auto i =
-        util::geo::intersection(util::geo::LineSegment<double>{rot1[0], rot1[1]},
-                                util::geo::LineSegment<double>{rot2[0], rot2[1]});
+    auto i = util::geo::intersection(
+        util::geo::LineSegment<double>{rot1[0], rot1[1]},
+        util::geo::LineSegment<double>{rot2[0], rot2[1]});
 
     line =
         util::geo::BezierCurve<double>(a, i, rot3[0], bb).render(5).getLine();

src/osmfixer/index/StatIdx.h

@@ -19,23 +19,26 @@ struct AttrErr {
   std::string attr;
   std::string otherAttr;
   double conf;
-  size_t otherId;
+  int64_t otherId;
 };
 
 struct Suggestion {
   uint16_t type;
   size_t station;
-  size_t target_gid, orig_gid, target_osm_rel_id, orig_osm_rel_id;
+  // 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 Station {
   size_t id;
-  size_t osmid;
+  // if negative, it is a way!
+  int64_t osmid;
   size_t origGroup, group;
-  util::geo::DPoint pos;
-  util::geo::DPoint latLng;
+  util::geo::DPoint centroid;
+  util::geo::DLine pos;
+  util::geo::DLine latLng;
   OsmAttrs attrs;
   std::vector<AttrErr> attrErrs;
   std::vector<size_t> suggestions;
@@ -43,8 +46,10 @@ struct Station {
 
 struct Group {
   size_t id;
-  size_t osmid;
+  int64_t osmid;
   util::geo::DPolygon poly;
+  util::geo::DPolygon llPoly;
+  util::geo::DPoint centroid;
   OsmAttrs attrs;
   std::vector<size_t> stations;
   std::vector<size_t> polyStations;
@@ -77,16 +82,17 @@ class StatIdx {
   const Suggestion* getSuggestion(size_t id) const;
 
   std::vector<Cluster> getHeatGridOk(const util::geo::DBox bbox,
-      size_t z) const;
+                                     size_t z) const;
 
   std::vector<Cluster> getHeatGridSugg(const util::geo::DBox bbox,
-      size_t z) const;
+                                       size_t z) const;
 
   std::vector<Cluster> getHeatGridErr(const util::geo::DBox bbox,
-      size_t z) const;
+                                      size_t z) const;
 
  private:
-  void addStation(size_t id, double lat, double lng, size_t origGroup,
+  void addStation(int64_t osmid, const util::geo::DLine& geom,
+                  const util::geo::DLine& latLngs, size_t origGroup,
                   size_t group, const OsmAttrs& attrs);
   void addGroup(size_t id, const OsmAttrs& attrs);
 
@@ -101,12 +107,13 @@ class StatIdx {
   std::vector<Suggestion> _suggestions;
   util::geo::DBox _bbox;
 
-  util::geo::Grid<size_t, util::geo::Point, double> _sgrid;
+  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::Line, double> _suggrid;
 
   std::vector<util::geo::Grid<Cluster, util::geo::Point, double>> _heatGridsOk;
-  std::vector<util::geo::Grid<Cluster, util::geo::Point, double>> _heatGridsSugg;
+  std::vector<util::geo::Grid<Cluster, util::geo::Point, double>>
+      _heatGridsSugg;
   std::vector<util::geo::Grid<Cluster, util::geo::Point, double>> _heatGridsErr;
 };
 }  // namespace osmfixer

src/osmfixer/server/StatServer.cpp

@@ -84,8 +84,8 @@ util::http::Answer StatServer::handleHeatMapReq(const Params& pars) const {
   std::stringstream json;
 
   size_t p = 5;
-  if (z < 11) p = 4;
-  if (z < 10) p = 3;
+  if (z < 11) p = 3;
+  if (z < 10) p = 2;
   if (z < 9) p = 2;
   if (z < 7) p = 1;
 
@@ -98,8 +98,8 @@ util::http::Answer StatServer::handleHeatMapReq(const Params& pars) const {
   for (const auto& idxPair : _idxs) {
     const auto& idx = idxPair.second;
 
-    auto hgOk = idx.getHeatGridOk(bbox, z);
-    for (auto cluster : hgOk) {
+    const auto& hgOk = idx.getHeatGridOk(bbox, z);
+    for (const auto& cluster : hgOk) {
       json << sep;
       sep = ',';
 
@@ -114,9 +114,9 @@ util::http::Answer StatServer::handleHeatMapReq(const Params& pars) const {
   for (const auto& idxPair : _idxs) {
     const auto& idx = idxPair.second;
 
-    auto hgSugg = idx.getHeatGridSugg(bbox, z);
+    const auto& hgSugg = idx.getHeatGridSugg(bbox, z);
 
-    for (auto cluster : hgSugg) {
+    for (const auto& cluster : hgSugg) {
       json << sep;
       sep = ',';
 
@@ -131,8 +131,8 @@ util::http::Answer StatServer::handleHeatMapReq(const Params& pars) const {
   for (const auto& idxPair : _idxs) {
     const auto& idx = idxPair.second;
 
-    auto hgErr = idx.getHeatGridErr(bbox, z);
-    for (auto cluster : hgErr) {
+    const auto& hgErr = idx.getHeatGridErr(bbox, z);
+    for (const auto& cluster : hgErr) {
       json << sep;
       sep = ',';
 
@@ -159,6 +159,9 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
   if (pars.count("cb")) cb = pars.find("cb")->second.c_str();
   auto box = util::split(pars.find("bbox")->second, ',');
 
+  double z = 0;
+  if (pars.count("z")) z = atoi(pars.find("z")->second.c_str());
+
   if (box.size() != 4) throw std::invalid_argument("Invalid request.");
 
   double lat1 = atof(box[0].c_str());
@@ -169,9 +172,19 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
   util::geo::DBox bbox(util::geo::DPoint(lat1, lng1),
                        util::geo::DPoint(lat2, lng2));
 
+  size_t p = 7;
+  if (z < 20) p = 6;
+  if (z < 17) p = 5;
+  if (z < 15) p = 4;
+  if (z < 13) p = 3;
+  if (z < 10) p = 2;
+  if (z < 9) p = 2;
+  if (z < 7) p = 1;
+
+
   std::stringstream json;
 
-  json << std::fixed << std::setprecision(6);
+  json << std::fixed << std::setprecision(p);
 
   if (cb.size()) json << cb << "(";
   json << "{\"stats\":[";
@@ -180,11 +193,11 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
   for (size_t did = 0; did < _idxs.size(); did++) {
     const auto& idx = _idxs[did].second;
 
-    auto ret = idx.getStations(bbox);
-    for (auto stat : ret) {
+    const auto& ret = idx.getStations(bbox);
+    for (const auto& stat : ret) {
       json << sep;
       sep = ',';
-      printStation(stat, did, &json);
+      printStation(stat, did, z < 15, &json);
     }
   }
 
@@ -193,25 +206,27 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
   for (size_t did = 0; did < _idxs.size(); did++) {
     const auto& idx = _idxs[did].second;
 
-    auto gret = idx.getGroups(bbox);
-    for (auto group : gret) {
+    const auto& gret = idx.getGroups(bbox);
+    for (const auto& group : gret) {
       if (group->polyStations.size() == 1 && group->osmid < 2) continue;
       json << sep;
       sep = ',';
-      printGroup(group, did, &json);
+      printGroup(group, did, z < 15, &json);
     }
   }
 
   json << "], \"su\":[";
   sep = ' ';
-  for (size_t did = 0; did < _idxs.size(); did++) {
-    const auto& idx = _idxs[did].second;
-
-    auto suggs = idx.getSuggestions(bbox);
-    for (auto sugg : suggs) {
-      json << sep;
-      sep = ',';
-      printSugg(sugg, did, &json);
+  if (z > 15) {
+    for (size_t did = 0; did < _idxs.size(); did++) {
+      const auto& idx = _idxs[did].second;
+
+      const auto& suggs = idx.getSuggestions(bbox);
+      for (const auto& sugg : suggs) {
+        json << sep;
+        sep = ',';
+        printSugg(sugg, did, &json);
+      }
     }
   }
 
@@ -226,21 +241,32 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
 }
 
 // _____________________________________________________________________________
-void StatServer::printStation(const Station* stat, size_t did,
+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;
 
-  auto latLng =
-      util::geo::webMercToLatLng<double>(stat->pos.getX(), stat->pos.getY());
-  (*out) << "{\"id\":" << stat->id + range.sidStart
-         << ",\"lat\":" << latLng.getY() << ",\"lon\":" << latLng.getX();
+  (*out) << "{\"i\":" << stat->id + range.sidStart << ",\"g\":[";
+
+  std::string sep = "";
+
+  if (simple) {
+      (*out) << sep << "[" << stat->centroid.getY() << "," << stat->centroid.getX() << "]";
+  } else {
+    for (const auto& ll : stat->latLng) {
+      (*out) << sep << "[" << ll.getY() << "," << ll.getX() << "]";
+      sep = ",";
+    }
+  }
+
+  (*out) << "]";
 
   if (stat->origGroup != stat->group || idx.getGroup(stat->group)->osmid == 1)
-    (*out) << ",\"su\":1";
+    (*out) << ",\"s\":1";
 
   if (stat->attrErrs.size())
-    (*out) << ",\"attrerrs\":" << stat->attrErrs.size();
+    (*out) << ",\"e\":" << stat->attrErrs.size();
+
   (*out) << "}";
 }
 
@@ -251,14 +277,14 @@ void StatServer::printSugg(const Suggestion* sugg, size_t did,
 
   std::vector<util::geo::DPoint> projArrow;
 
-  for (auto p : sugg->arrow) {
+  for (const auto& p : sugg->arrow) {
     projArrow.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
   }
 
-  (*out) << "{\"id\":" << sugg->station + range.suggIdStart
-         << ",\"type\":" << sugg->type << ",\"arrow\":[";
+  (*out) << "{\"i\":" << sugg->station + range.suggIdStart
+         << ",\"t\":" << sugg->type << ",\"a\":[";
   char sep = ' ';
-  for (auto p : projArrow) {
+  for (const auto& p : projArrow) {
     (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
     sep = ',';
   }
@@ -267,24 +293,22 @@ void StatServer::printSugg(const Suggestion* sugg, size_t did,
 }
 
 // _____________________________________________________________________________
-void StatServer::printGroup(const Group* group, size_t did,
+void StatServer::printGroup(const Group* group, size_t did, bool simple,
                             std::ostream* out) const {
   const auto& range = _idxs[did].first;
 
-  std::vector<util::geo::DPoint> projPoly;
-
-  for (auto p : group->poly.getOuter()) {
-    projPoly.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
-  }
-
-  (*out) << "{\"id\":" << group->id + range.gidStart << ",\"poly\":[";
+  (*out) << "{\"i\":" << group->id + range.gidStart << ",\"g\":[";
   char sep = ' ';
-  for (auto p : projPoly) {
-    (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
-    sep = ',';
+  if (simple) {
+    (*out) << sep << "[" << group->centroid.getY() << "," << group->centroid.getX() << "]";
+  } else {
+    for (const auto& p : group->llPoly.getOuter()) {
+      (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
+      sep = ',';
+    }
   }
   (*out) << "]";
-  if (group->osmid == 1) (*out) << ",\"new\":1";
+  if (group->osmid == 1) (*out) << ",\"n\":1";
   (*out) << "}";
 }
 
@@ -295,7 +319,7 @@ std::string StatServer::parseUrl(std::string u, std::string pl,
 
   if (parts.size() > 1) {
     auto kvs = util::split(parts[1], '&');
-    for (auto kv : kvs) {
+    for (const auto& kv : kvs) {
       auto kvp = util::split(kv, '=');
       if (kvp.size() == 1) kvp.push_back("");
       (*params)[util::urlDecode(kvp[0])] = kvp[1];
@@ -304,7 +328,7 @@ std::string StatServer::parseUrl(std::string u, std::string pl,
 
   // also parse post data
   auto kvs = util::split(pl, '&');
-  for (auto kv : kvs) {
+  for (const auto& kv : kvs) {
     auto kvp = util::split(kv, '=');
     if (kvp.size() == 1) kvp.push_back("");
     (*params)[util::urlDecode(kvp[0])] = kvp[1];
@@ -358,7 +382,7 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
   const auto& idx = _idxs[did].second;
   size_t idxGid = gid - range.gidStart;
 
-  auto group = idx.getGroup(idxGid);
+  const auto& group = idx.getGroup(idxGid);
 
   if (!group) return util::http::Answer("404 Not Found", "Group not found.");
 
@@ -393,7 +417,7 @@ util::http::Answer StatServer::handleGroupReq(const Params& pars) const {
   for (const auto& sid : group->stations) {
     json << sep;
     sep = ',';
-    const auto stat = idx.getStation(sid);
+    const auto& stat = idx.getStation(sid);
     json << "{\"id\":" << sid + range.sidStart << ","
          << "\"osmid\":" << stat->osmid << ","
          << "\"group\":" << stat->group + range.gidStart << ","
@@ -445,7 +469,7 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
   const auto& idx = _idxs[did].second;
   size_t idxSid = sid - range.sidStart;
 
-  auto stat = idx.getStation(idxSid);
+  const auto& stat = idx.getStation(idxSid);
 
   if (!stat) return util::http::Answer("404 Not Found", "Station not found.");
 
@@ -453,11 +477,13 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
 
   json << std::fixed << std::setprecision(6);
 
+  auto centroid = util::geo::centroid(stat->latLng);
+
   if (cb.size()) json << cb << "(";
   json << "{\"id\":" << sid << ","
        << "\"osmid\":" << stat->osmid << ","
-       << "\"lat\":" << stat->latLng.getY() << ","
-       << "\"lon\":" << stat->latLng.getX() << ","
+       << "\"lat\":" << centroid.getY() << ","
+       << "\"lon\":" << centroid.getX() << ","
        << "\"attrs\":{";
 
   char sep = ' ';
@@ -482,7 +508,7 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
   for (const auto& err : stat->attrErrs) {
     json << sep;
     sep = ',';
-    const auto otherStat = idx.getStation(err.otherId);
+    const auto& otherStat = idx.getStation(err.otherId);
     json << "{";
     json << "\"attr\":[\"" << err.attr << "\",\"" << stat->attrs.at(err.attr)[0]
          << "\"]";
@@ -537,7 +563,7 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
     }
   }
 
-  for (auto attrErr : stat->attrErrs) {
+  for (const auto& attrErr : stat->attrErrs) {
     const auto otherStat = idx.getStation(attrErr.otherId);
     if (otherStat->osmid == stat->osmid) {
       // fix attributes

src/osmfixer/server/StatServer.h

@@ -35,8 +35,8 @@ class StatServer : public util::http::Handler {
   util::http::Answer handleStatReq(const Params& pars) const;
   util::http::Answer handleGroupReq(const Params& pars) const;
 
-  void printStation(const Station* stat, size_t did, std::ostream* out) const;
-  void printGroup(const Group* stat, size_t did, std::ostream* out) 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;
   void printSugg(const Suggestion* stat, size_t did, std::ostream* out) const;
 
   size_t getDidBySid(size_t sid) const;

web/script.js

@@ -1,31 +1,43 @@
-widths = [12, 13, 13, 13, 13, 13, 13, 13];
-opas = [0.8, 0.6, 0.5, 0.5, 0.4];
-mwidths = [1, 1, 1, 1.5, 2, 3, 5, 6, 6, 4, 3, 2];
+var widths = [12, 13, 13, 13, 13, 13, 13, 13];
+var opas = [0.8, 0.6, 0.5, 0.5, 0.4];
+var mwidths = [1, 1, 1, 1.5, 2, 3, 5, 6, 6, 4, 3, 2];
 
-backend = "";
+var backend = "";
+var openGr = -1;
+var openSt = -1;
 
 function marker(stat, z) {
-    if (z > 15) {
-        return L.circle(
-            [stat.lat, stat.lon], {
-                color: 'black',
-                fillColor: stat.attrerrs ? 'red' : stat.su ? '#0000c3' : '#78f378',
-                radius: mwidths[23 - z],
-                fillOpacity: 1,
-                weight: 1,
-                id: stat.id
-            }
-        );
+    if (stat.g.length == 1) {
+        if (z > 15) {
+            return L.circle(
+                stat.g[0], {
+                    color: 'black',
+                    fillColor: stat.e ? 'red' : stat.s ? '#0000c3' : '#78f378',
+                    radius: mwidths[23 - z],
+                    fillOpacity: 1,
+                    weight: z > 17 ? 1.5 : 1,
+                    id: stat.i
+                }
+            );
+        } else {
+            return L.polyline(
+                [stat.g[0], stat.g[0]], {
+                    color: stat.e ? 'red' : stat.s ? '#0000c3' : '#78f378',
+                    weight: widths[15 - z],
+                    opacity: opas[15 - z],
+                    id: stat.i
+                }
+            );
+        }
     } else {
-        return L.polyline(
-            [
-                [stat.lat, stat.lon],
-                [stat.lat, stat.lon]
-            ], {
-                color: stat.attrerrs ? 'red' : stat.su ? '#0000c3' : '#78f378',
-                weight: widths[15 - z],
-                opacity: opas[15 - z],
-                id: stat.id
+        return L.polygon(
+            stat.g, {
+                color: z > 15 ? 'black': (stat.e ? 'red' : stat.s ? '#0000c3' : '#78f378'),
+                fillColor: stat.e ? 'red' : stat.s ? '#0000c3' : '#78f378',
+                smoothFactor: 0,
+                fillOpacity: 0.75,
+                weight: z > 17 ? 1.5 : 1,
+                id: stat.i
             }
         );
     }
@@ -34,24 +46,26 @@ function marker(stat, z) {
 function poly(group, z) {
     var style = {
         color: "#85f385",
+        fillColor: "#85f385",
         smoothFactor: 0.4,
         fillOpacity: 0.2,
-        id: group.id
+        id: group.i
     };
     if (group.new) {
         style.color = "#0000c3";
+        style.fillColor = "#0000c3";
     }
     if (z < 16) {
         style.weight = 11;
         style.opacity = 0.5;
         style.fillOpacity = 0.5;
     }
-    return L.polygon(group.poly, style)
+    return L.polygon(group.g, style)
 }
 
 function sugArr(sug, z) {
-    return L.polyline(sug.arrow, {
-        id: sug.id,
+    return L.polyline(sug.a, {
+        id: sug.i,
         color: '#0000c3',
         smoothFactor: 0.1,
         weight: 4,
@@ -60,12 +74,18 @@ function sugArr(sug, z) {
 }
 
 function renderStat(stat) {
+    openSt = stat.id;
+    nodeHl(stat.id);
     var attrrows = {};
     var ll = {
         lat: stat.lat,
         lon: stat.lon
     };
 
+    var way = stat.osmid < 0;
+    var osmid = Math.abs(stat.osmid);
+    var ident = way ? "Way" : "Node";
+
     var content = document.createElement('div');
     content.setAttribute("id", "nav")
     var attrTbl = document.createElement('table');
@@ -73,12 +93,14 @@ function renderStat(stat) {
     var suggD = document.createElement('div');
     suggD.setAttribute("id", "sugg")
 
+    content.innerHTML = ident + " <a target='_blank' href='https://www.openstreetmap.org/"+ident.toLowerCase()+"/" + osmid + "'>" + osmid + "</a>";
+
     if (stat.attrs.name) {
-        content.innerHTML = "Node <a onmouseover='nodeHl( " + stat.id + ")' onmouseout='nodeUnHl( " + stat.id + ")' target='_blank' href='https://www.openstreetmap.org/node/" + stat.osmid + "'>" + stat.osmid + "</a> (<b>\"" + stat.attrs.name + "\"</b>)";
-    } else {
-        content.innerHTML = "Node <a onmouseover='nodeHl( " + stat.id + ")' onmouseout='nodeUnHl( " + stat.id + ")' target='_blank' href='https://www.openstreetmap.org/node/" + stat.osmid + "'>" + stat.osmid + "</a>";
+        content.innerHTML += " (<b>\"" + stat.attrs.name + "\"</b>)";
     }
 
+    content.innerHTML += "<a class='editbut' target='_blank' href='https://www.openstreetmap.org/edit?" + ident.toLowerCase() + "=" + osmid +"'>&#9998;</a>";
+
     content.appendChild(attrTbl);
     content.appendChild(suggD);
 
@@ -106,7 +128,8 @@ function renderStat(stat) {
         var info = document.createElement('div');
 
         if (err.other_osmid != stat.osmid) {
-            info.innerHTML = "Does not match <tt>" + err.other_attr[0] + "</tt> in node <a onmouseover='nodeHl( " + err.other + ")' onmouseout='nodeUnHl( " + err.other + ")' target=\"_blank\" href=\"https://www.openstreetmap.org/node/" + err.other_osmid + "\">" + err.other_osmid + "</a>";
+            var ident = stat.osmid < 0 ? "way" : "node";
+            info.innerHTML = "Does not match <tt>" + err.other_attr[0] + "</tt> in " + ident + " <a onmouseover='nodeHl( " + err.other + ")' onmouseout='nodeUnHl( " + err.other + ")' target=\"_blank\" href=\"https://www.openstreetmap.org/"+ident+"/" + Math.abs(err.other_osmid) + "\">" + Math.abs(err.other_osmid) + "</a>";
         } else {
             info.innerHTML = "Does not match '" + err.other_attr[0] + "' = '" + err.other_attr[1];
         }
@@ -158,7 +181,8 @@ function renderStat(stat) {
         })
         .setLatLng(ll)
         .setContent(content)
-        .openOn(map);
+        .openOn(map)
+        .on('remove', function() {openSt = -1; nodeUnHl(stat.id);;});
 }
 
 function openStat(id) {
@@ -175,7 +199,9 @@ function openStat(id) {
 }
 
 function renderGroup(grp, ll) {
+    openGr = grp.id;
     var attrrows = {};
+    groupHl(grp.id);
 
     var content = document.createElement('div');
     content.setAttribute("id", "nav");
@@ -189,9 +215,10 @@ function renderGroup(grp, ll) {
     oldMembers.innerHTML = "<span class='oldmemberstit'>Existing Members</span>";
 
     if (grp.osmid == 1) {
-        content.innerHTML = "<span class='grouplink' onmouseover='groupHl( " + grp.id + ")' onmouseout='groupUnHl( " + grp.id + ")'>New relation</span> <tt>public_transport=stop_area</tt>";
+        content.innerHTML = "<span class='grouplink'>New relation</span> <tt>public_transport=stop_area</tt>";
     } else {
-        content.innerHTML = "OSM relation <a onmouseover='groupHl( " + grp.id + ")' onmouseout='groupUnHl( " + grp.id + ")' target='_blank' href='https://www.openstreetmap.org/relation/" + grp.osmid + "'>" + grp.osmid + "</a>";
+        content.innerHTML = "OSM relation <a target='_blank' href='https://www.openstreetmap.org/relation/" + grp.osmid + "'>" + grp.osmid + "</a>";
+        content.innerHTML += "<a class='editbut' target='_blank' href='https://www.openstreetmap.org/edit?relation=" + grp.osmid +"'>&#9998;</a>";
     }
 
     content.appendChild(newMembers);
@@ -200,11 +227,12 @@ function renderGroup(grp, ll) {
     for (var key in grp.stations) {
         var stat = grp.stations[key];
         var row = document.createElement('div');
+        var ident = stat.osmid < 0 ? "Way" : "Node";
+
+        row.innerHTML = ident + " <a onmouseover='nodeHl( " + stat.id + ")' onmouseout='nodeUnHl( " + stat.id + ")' target='_blank' href='https://www.openstreetmap.org/" + ident.toLowerCase() + "/" + Math.abs(stat.osmid) + "'>" + Math.abs(stat.osmid) + "</a>";
 
         if (stat.attrs.name) {
-            row.innerHTML = "Node <a onmouseover='nodeHl( " + stat.id + ")' onmouseout='nodeUnHl( " + stat.id + ")' target='_blank' href='https://www.openstreetmap.org/node/" + stat.osmid + "'>" + stat.osmid + "</a> (<b>\"" + stat.attrs.name + "\"</b>)";
-        } else {
-            row.innerHTML = "Node <a onmouseover='nodeHl( " + stat.id + ")' onmouseout='nodeUnHl( " + stat.id + ")' target='_blank' href='https://www.openstreetmap.org/node/" + stat.osmid + "'>" + stat.osmid + "</a>";
+            row.innerHTML += " (<b>\"" + stat.attrs.name + "\"</b>)";
         }
 
         if (grp.osmid == 1 || stat.orig_group != grp.id) newMembers.appendChild(row);
@@ -227,7 +255,8 @@ function renderGroup(grp, ll) {
         })
         .setLatLng(ll)
         .setContent(content)
-        .openOn(map);
+        .openOn(map)
+        .on('remove', function() {openGr = -1; groupUnHl(grp.id)});
 }
 
 function openGroup(id, ll) {
@@ -247,7 +276,7 @@ function groupHl(id) {
     if (!document.groupIdx[id]) return;
     document.groupIdx[id].setStyle({
         'weight': 6,
-        'fillOpacity': 0.5
+        'color': "#eecc00"
     });
 }
 
@@ -255,7 +284,7 @@ function groupUnHl(id) {
     if (!document.groupIdx[id]) return;
     document.groupIdx[id].setStyle({
         'weight': 3,
-        'fillOpacity': 0.2
+        'color': document.groupIdx[id].options["fillColor"]
     });
 }
 
@@ -285,10 +314,10 @@ 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>'
 }));
 
-L.tileLayer('https://cartodb-basemaps-{s}.global.ssl.fastly.net/light_all/{z}/{x}/{y}.png', {
-    maxZoom: 23,
-    attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>, &copy; <a href="https://carto.com/attribution">CARTO</a>',
-    id: 'mapbox.streets'
+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>',
+    opacity: 0.8
 }).addTo(map);
 
 var layer = L.featureGroup().addTo(map);
@@ -368,7 +397,7 @@ function render() {
                     stat = content.stats[i];
                     var ndMarker = marker(stat, map.getZoom());
                     stations.push(ndMarker);
-                    document.nodeIdx[stat.id] = ndMarker;
+                    document.nodeIdx[stat.i] = ndMarker;
                 }
 
                 var groups = [];
@@ -376,7 +405,7 @@ function render() {
                     group = content.groups[i];
                     var groupPoly = poly(group, map.getZoom());
                     groups.push(groupPoly);
-                    document.groupIdx[group.id] = groupPoly;
+                    document.groupIdx[group.i] = groupPoly;
                 }
 
                 var suggs = [];
@@ -402,10 +431,13 @@ function render() {
                 layer.addLayer(L.featureGroup(stations).on('click', function(a) {
                     openStat(a.layer.options.id);
                 }));
+
+                groupHl(openGr);
+                nodeHl(openSt);
             }
         };
 
-        window.xmlhttp.open("GET", backend + "/map?bbox=" + [map.getBounds().getSouthWest().lat, map.getBounds().getSouthWest().lng, map.getBounds().getNorthEast().lat, map.getBounds().getNorthEast().lng].join(","), true);
+        window.xmlhttp.open("GET", backend + "/map?z=" + map.getZoom() + "&bbox=" + [map.getBounds().getSouthWest().lat, map.getBounds().getSouthWest().lng, map.getBounds().getNorthEast().lat, map.getBounds().getNorthEast().lng].join(","), true);
         window.xmlhttp.send();
     }
 }