changes

src/osmfixer/index/StatIdx.cpp

@@ -8,11 +8,13 @@
 #include <sstream>
 #include <string>
 #include "osmfixer/index/StatIdx.h"
+#include "util/geo/BezierCurve.h"
 
 using osmfixer::StatIdx;
 using osmfixer::OsmAttrs;
 using osmfixer::Station;
 using osmfixer::Group;
+using osmfixer::Suggestion;
 
 // _____________________________________________________________________________
 void StatIdx::readFromFile(const std::string& path) {
@@ -90,6 +92,7 @@ void StatIdx::readFromFile(const std::string& path) {
   }
 
   initGroups();
+  initSuggestions();
   initIndex();
 }
 
@@ -126,7 +129,7 @@ void StatIdx::initGroups() {
     assert(_stations[i].group < _groups.size());
     if (_stations[i].group != _stations[i].origGroup &&
         _groups[_stations[i].group].osmid == 1) {
-			std::cout << "MURR" << std::endl;
+      std::cout << "MURR" << std::endl;
       // only add non-orig groups to polygons of new (non-osm) groups
       _groups[_stations[i].group].stations.push_back(i);
     }
@@ -157,8 +160,33 @@ void StatIdx::initIndex() {
                                                              false);
   _ggrid = util::geo::Grid<size_t, util::geo::Polygon, double>(5000, 5000,
                                                                _bbox, false);
+  _suggrid = util::geo::Grid<size_t, util::geo::Line, double>(5000, 5000, _bbox,
+                                                              false);
   for (size_t i = 0; i < _stations.size(); i++) _sgrid.add(_stations[i].pos, i);
   for (size_t i = 0; i < _groups.size(); i++) _ggrid.add(_groups[i].poly, i);
+  for (size_t i = 0; i < _suggestions.size(); i++)
+    _suggrid.add(_suggestions[i].arrow, i);
+}
+
+// _____________________________________________________________________________
+std::vector<const Suggestion*> StatIdx::getSuggestions(
+    const util::geo::DBox bbox) const {
+  std::vector<const Suggestion*> 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);
+  _suggrid.get(reqBox, &tmp);
+
+  for (auto i : tmp) {
+    if (util::geo::intersects(_suggestions[i].arrow, reqBox))
+      ret.push_back(&_suggestions[i]);
+  }
+
+  return ret;
 }
 
 // _____________________________________________________________________________
@@ -209,7 +237,118 @@ const Station* StatIdx::getStation(size_t id) const {
 }
 
 // _____________________________________________________________________________
+void StatIdx::initSuggestions() {
+  for (size_t i = 0; i < _stations.size(); i++) {
+    auto& stat = _stations[i];
+    if (stat.group != stat.origGroup || getGroup(stat.group)->osmid == 1) {
+      Suggestion sug;
+      sug.station = i;
+      sug.arrow = util::geo::DLine{stat.pos, stat.pos};
+      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);
+
+        } else if (getGroup(stat.group)->osmid > 1) {
+          // move orphan into existing group
+          sug.type = 2;
+          sug.target_gid = stat.group;
+          sug.target_osm_rel_id = getGroup(stat.group)->osmid;
+
+          sug.arrow = getGroupArrow(i, stat.group);
+
+          _suggestions.push_back(sug);
+          stat.suggestions.push_back(_suggestions.size() - 1);
+        }
+      } else {
+        if (getGroup(stat.group)->osmid == 1) {
+          // move station from relation into new group
+          sug.type = 3;
+          sug.orig_gid = stat.origGroup;
+          sug.orig_osm_rel_id = getGroup(stat.origGroup)->osmid;
+          sug.target_gid = stat.group;
+
+          sug.arrow = getGroupArrow(i, stat.group);
+
+          _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;
+          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;
+
+          _suggestions.push_back(sug);
+          stat.suggestions.push_back(_suggestions.size() - 1);
+        } else {
+          // move station out of relation
+          sug.type = 5;
+          sug.orig_gid = stat.origGroup;
+          sug.target_gid = stat.group;
+          sug.target_osm_rel_id = getGroup(stat.group)->osmid;
+
+          _suggestions.push_back(sug);
+          stat.suggestions.push_back(_suggestions.size() - 1);
+        }
+      }
+    }
+  }
+}
+
+// _____________________________________________________________________________
+util::geo::DLine StatIdx::getGroupArrow(size_t stat, size_t group) const {
+  auto a = getStation(stat)->pos;
+  auto b = util::geo::centroid(getGroup(group)->poly);
+
+  auto pl = util::geo::PolyLine<double>(a, b);
+  auto bb = pl.getPointAtDist(fmax(pl.getLength() / 2, pl.getLength() - 20)).p;
+
+  int side = rand() % 2;
+  if (!side) side = -1;
+
+
+  auto rot1 = util::geo::rotate(util::geo::DLine{a, bb}, 45 * side, a);
+  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 line = util::geo::BezierCurve<double>(a, i, rot3[0], bb).render(1).getLine();
+
+  // arrowhead
+  auto pl2 = util::geo::PolyLine<double>(line);
+  util::geo::LineSegment<double> headSeg(pl2.getPointAtDist(pl2.getLength() - 5).p, line.back());
+  auto arrHeadLeft = util::geo::rotate(headSeg, -45, line.back()).first;
+  auto arrHeadRight = util::geo::rotate(headSeg, 45, line.back()).first;
+
+  auto tmp = line.back();
+
+  line.push_back(arrHeadLeft);
+  line.push_back(tmp);
+  line.push_back(arrHeadRight);
+
+  return line;
+}
+
+// _____________________________________________________________________________
 const Group* StatIdx::getGroup(size_t id) const {
   if (id >= _groups.size()) return 0;
   return &_groups[id];
 }
+
+// _____________________________________________________________________________
+const Suggestion* StatIdx::getSuggestion(size_t id) const {
+  if (id >= _suggestions.size()) return 0;
+  return &_suggestions[id];
+}

src/osmfixer/index/StatIdx.h

@@ -22,6 +22,13 @@ struct AttrErr {
   size_t otherId;
 };
 
+struct Suggestion {
+  uint16_t type;
+  size_t station;
+  size_t target_gid, orig_gid, target_osm_rel_id, orig_osm_rel_id;
+  util::geo::DLine arrow;
+};
+
 struct Station {
   size_t id;
   size_t osmid;
@@ -29,6 +36,7 @@ struct Station {
   util::geo::DPoint pos;
   OsmAttrs attrs;
   std::vector<AttrErr> attrErrs;
+  std::vector<size_t> suggestions;
 };
 
 struct Group {
@@ -47,9 +55,11 @@ class StatIdx {
 
   std::vector<const Station*> getStations(const util::geo::DBox bbox) const;
   std::vector<const Group*> getGroups(const util::geo::DBox bbox) const;
+  std::vector<const Suggestion*> getSuggestions(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;
 
  private:
   void addStation(size_t id, double lat, double lng, size_t origGroup,
@@ -58,13 +68,18 @@ class StatIdx {
 
   void initIndex();
   void initGroups();
+  void initSuggestions();
+
+  util::geo::DLine getGroupArrow(size_t stat, size_t group) const;
 
   std::vector<Station> _stations;
   std::vector<Group> _groups;
+  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> _ggrid;
+  util::geo::Grid<size_t, util::geo::Line, double> _suggrid;
 };
 }  // namespace osmfixer
 

src/osmfixer/server/StatServer.cpp

@@ -25,6 +25,8 @@ util::http::Answer StatServer::handle(const util::http::Req& req,
       a = util::http::Answer("200 OK", "osmfixer");
     } else if (cmd == "/map") {
       a = handleMapReq(params);
+    } else if (cmd == "/heatmap") {
+      a = handleHeatMapReq(params);
     } else if (cmd == "/stat") {
       a = handleStatReq(params);
     } else {
@@ -46,6 +48,82 @@ util::http::Answer StatServer::handle(const util::http::Req& req,
 }
 
 // _____________________________________________________________________________
+util::http::Answer StatServer::handleHeatMapReq(const Params& pars) const {
+  if (pars.count("bbox") == 0 || pars.find("bbox")->second.empty())
+    throw std::invalid_argument("No bbox specified.");
+  std::string cb;
+  if (pars.count("cb")) cb = pars.find("cb")->second.c_str();
+  auto box = util::split(pars.find("bbox")->second, ',');
+
+  if (box.size() != 4) throw std::invalid_argument("Invalid request.");
+
+  double lat1 = atof(box[0].c_str());
+  double lng1 = atof(box[1].c_str());
+  double lat2 = atof(box[2].c_str());
+  double lng2 = atof(box[3].c_str());
+
+  std::cout << pars.find("bbox")->second << std::endl;
+
+  util::geo::DBox bbox(util::geo::DPoint(lat1, lng1),
+                       util::geo::DPoint(lat2, lng2));
+
+  std::stringstream json;
+
+  json << std::setprecision(10);
+
+  if (cb.size()) json << cb << "(";
+  json << "{\"ok\":[";
+
+  auto ret = _idx->getStations(bbox);
+  char sep = ' ';
+  for (auto stat : ret) {
+    if (stat->suggestions.size() != 0 || stat->attrErrs.size() != 0) continue;
+    json << sep;
+    sep = ',';
+
+    auto latLng =
+        util::geo::webMercToLatLng<double>(stat->pos.getX(), stat->pos.getY());
+    json << "[" << latLng.getY() << "," << latLng.getX() << "," << "0.5" << "]";
+  }
+
+
+  json << "],\"sugg\":[";
+
+  sep = ' ';
+  for (auto stat : ret) {
+    if (stat->suggestions.size() == 0) continue;
+    json << sep;
+    sep = ',';
+
+    auto latLng =
+        util::geo::webMercToLatLng<double>(stat->pos.getX(), stat->pos.getY());
+    json << "[" << latLng.getY() << "," << latLng.getX() << "," << "0.5" << "]";
+  }
+
+  json << "],\"err\":[";
+
+  sep = ' ';
+  for (auto stat : ret) {
+    if (stat->attrErrs.size() == 0) continue;
+    json << sep;
+    sep = ',';
+
+    auto latLng =
+        util::geo::webMercToLatLng<double>(stat->pos.getX(), stat->pos.getY());
+    json << "[" << latLng.getY() << "," << latLng.getX() << "," << "0.5" << "]";
+  }
+
+  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::handleMapReq(const Params& pars) const {
   if (pars.count("bbox") == 0 || pars.find("bbox")->second.empty())
     throw std::invalid_argument("No bbox specified.");
@@ -92,6 +170,15 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
     printGroup(group, &json);
   }
 
+  json << "], \"suggestions\":[";
+  auto suggs = _idx->getSuggestions(bbox);
+  sep = ' ';
+  for (auto sugg : suggs) {
+    json << sep;
+    sep = ',';
+    printSugg(sugg, &json);
+  }
+
   json << "]}";
 
   if (cb.size()) json << ")";
@@ -118,12 +205,32 @@ void StatServer::printStation(const Station* stat, std::ostream* out) const {
 }
 
 // _____________________________________________________________________________
+void StatServer::printSugg(const Suggestion* sugg, std::ostream* out) {
+  std::vector<util::geo::DPoint> projArrow;
+
+  for (auto p : sugg->arrow) {
+    projArrow.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
+  }
+
+  (*out) << "{\"id\":" << sugg->station << ",\"type\":" << sugg->type
+         << ",\"arrow\":[";
+  char sep = ' ';
+  for (auto p : projArrow) {
+    (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
+    sep = ',';
+  }
+  (*out) << "]";
+  (*out) << "}";
+}
+
+// _____________________________________________________________________________
 void StatServer::printGroup(const Group* group, std::ostream* out) {
   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 << ",\"poly\":[";
   char sep = ' ';
   for (auto p : projPoly) {
@@ -220,7 +327,8 @@ util::http::Answer StatServer::handleStatReq(const Params& pars) const {
   json << ",\"suggestions\":[";
 
   // suggestions
-  if (stat->group != stat->origGroup || _idx->getGroup(stat->group)->osmid == 1) {
+  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 << "}";

src/osmfixer/server/StatServer.h

@@ -25,10 +25,12 @@ class StatServer : public util::http::Handler {
   static std::string parseUrl(std::string u, std::string pl, Params* params);
 
   util::http::Answer handleMapReq(const Params& pars) const;
+  util::http::Answer handleHeatMapReq(const Params& pars) const;
   util::http::Answer handleStatReq(const Params& pars) const;
 
   void printStation(const Station* stat, std::ostream* out) const;
   static void printGroup(const Group* stat, std::ostream* out);
+  static void printSugg(const Suggestion* stat, std::ostream* out);
 
   const osmfixer::StatIdx* _idx;
 };

src/util/geo/BezierCurve.h

@@ -27,7 +27,8 @@ struct CubicPolynom {
 template <typename T>
 class BezierCurve {
  public:
-  BezierCurve(const Point<T>& a, const Point<T>& b, const Point<T>& c, const Point<T>& d);
+  BezierCurve(const Point<T>& a, const Point<T>& b, const Point<T>& c,
+              const Point<T>& d);
 
   const PolyLine<T>& render(double d);