changes

src/osmfixer/index/StatIdx.cpp

@@ -62,7 +62,7 @@ void StatIdx::addStation(size_t osmid, double lat, double lng, size_t group,
   std::cout << "Record: " << osmid << " " << lat << " " << lng << std::endl;
   auto point = util::geo::latLngToWebMerc<double>(lat, lng);
 
-  _stations.emplace_back(Station{osmid, group, point, attrs});
+  _stations.emplace_back(Station{_stations.size(), osmid, group, point, attrs});
 
   // extend bounding box
   _bbox = util::geo::extendBox(point, _bbox);
@@ -72,6 +72,7 @@ void StatIdx::addStation(size_t osmid, double lat, double lng, size_t group,
 void StatIdx::addGroup(size_t osmid, const OsmAttrs& attrs) {
   std::cout << osmid << std::endl;
   Group g;
+	g.id = _groups.size();
   g.osmid = osmid;
   g.attrs = attrs;
   _groups.emplace_back(g);
@@ -89,8 +90,8 @@ void StatIdx::initGroups() {
     util::geo::MultiPoint<double> mp;
     for (size_t stid : _groups[i].stations) {
       double rad = 11.0;
-      int n = 50.0;
-      for (int i = 0; i <= n; i++) {
+      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)) *
@@ -110,13 +111,8 @@ void StatIdx::initIndex() {
                                                              false);
   _ggrid = util::geo::Grid<size_t, util::geo::Polygon, 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 < _stations.size(); i++) _sgrid.add(_stations[i].pos, i);
+  for (size_t i = 0; i < _groups.size(); i++) _ggrid.add(_groups[i].poly, i);
 }
 
 // _____________________________________________________________________________
@@ -159,3 +155,16 @@ std::vector<const Station*> StatIdx::getStations(
 
   return ret;
 }
+
+// _____________________________________________________________________________
+const Station* StatIdx::getStation(size_t id) const {
+	if (id >= _stations.size()) return 0;
+	return &_stations[id];
+}
+
+
+// _____________________________________________________________________________
+const Group* StatIdx::getGroup(size_t id) const {
+	if (id >= _groups.size()) return 0;
+	return &_groups[id];
+}

src/osmfixer/index/StatIdx.h

@@ -16,6 +16,7 @@ namespace osmfixer {
 typedef std::map<std::string, std::vector<std::string>> OsmAttrs;
 
 struct Station {
+  size_t id;
   size_t osmid;
   size_t group;
   util::geo::DPoint pos;
@@ -23,6 +24,7 @@ struct Station {
 };
 
 struct Group {
+  size_t id;
   size_t osmid;
   util::geo::DPolygon poly;
   OsmAttrs attrs;
@@ -38,6 +40,9 @@ class StatIdx {
   std::vector<const Station*> getStations(const util::geo::DBox bbox) const;
   std::vector<const Group*> getGroups(const util::geo::DBox bbox) const;
 
+  const Station* getStation(size_t id) const;
+  const Group* getGroup(size_t id) const;
+
  private:
   void addStation(size_t id, double lat, double lng, size_t group,
                   const OsmAttrs& attrs);

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 == "/stat") {
+      a = handleStatReq(params);
     } else {
       a = util::http::Answer("404 Not Found", "dunno");
     }
@@ -103,7 +105,7 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
 void StatServer::printStation(const Station* stat, std::ostream* out) {
   auto latLng =
       util::geo::webMercToLatLng<double>(stat->pos.getX(), stat->pos.getY());
-  (*out) << "{\"id\":" << stat->osmid << ",\"lat\":"
+  (*out) << "{\"id\":" << stat->id << ",\"lat\":"
          << latLng.getY() << ",\"lon\":" << latLng.getX() << "}";
 }
 
@@ -114,7 +116,7 @@ void StatServer::printGroup(const Group* group, std::ostream* out) {
   for (auto p : group->poly.getOuter()) {
     projPoly.push_back(util::geo::webMercToLatLng<double>(p.getX(), p.getY()));
   }
-  (*out) << "{\"id\":" << group->osmid << ",\"poly\":[";
+  (*out) << "{\"id\":" << group->id << ",\"poly\":[";
   char sep = ' ';
   for (auto p : projPoly) {
     (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
@@ -147,3 +149,50 @@ std::string StatServer::parseUrl(std::string u, std::string pl,
 
   return util::urlDecode(parts.front());
 }
+
+// _____________________________________________________________________________
+util::http::Answer StatServer::handleStatReq(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 sid = atol(pars.find("id")->second.c_str());
+  auto stat = _idx->getStation(sid);
+
+  if (!stat) return util::http::Answer("404 Not Found", "Station not found.");
+
+  std::stringstream json;
+
+  json << std::setprecision(10);
+
+  if (cb.size()) json << cb << "(";
+  json << "{\"id\":" << sid << ","
+    << "\"osmid\":" << stat->osmid << ","
+    << "\"attrs\":{";
+
+  char sep = ' ';
+
+  for (const auto& par : stat->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 (cb.size()) json << ")";
+
+  auto answ = util::http::Answer("200 OK", json.str(), true);
+  answ.params["Content-Type"] = "application/javascript; charset=utf-8";
+
+  return answ;
+}

src/osmfixer/server/StatServer.h

@@ -25,6 +25,7 @@ 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 handleStatReq(const Params& pars) const;
 
   static void printStation(const Station* stat, std::ostream* out);
   static void printGroup(const Group* stat, std::ostream* out);

src/util/geo/Geo.h

@@ -1269,7 +1269,7 @@ inline Polygon<T> convexHull(const RotatedBox<T>& b) {
 // _____________________________________________________________________________
 template <typename T>
 inline size_t convexHullImpl(const MultiPoint<T>& a, size_t p1, size_t p2,
-                             Line<T>* h, uint8_t d) {
+                             Line<T>* h) {
   // quickhull by Barber, Dobkin & Huhdanpaa
   Point<T> pa;
   bool found = false;
@@ -1277,7 +1277,7 @@ inline size_t convexHullImpl(const MultiPoint<T>& a, size_t p1, size_t p2,
   for (const auto& p : a) {
     double tmpDist = distToSegment((*h)[p1], (*h)[p2], p);
     double cp = crossProd(p, LineSegment<T>((*h)[p1], (*h)[p2]));
-    if (((cp > 0 && !d) || (cp < 0 && d)) && tmpDist >= maxDist + EPSILON) {
+    if ((cp > 0) && tmpDist > maxDist) {
       pa = p;
       found = true;
       maxDist = tmpDist;
@@ -1286,9 +1286,9 @@ inline size_t convexHullImpl(const MultiPoint<T>& a, size_t p1, size_t p2,
 
   if (!found) return 0;
 
-  h->insert(h->begin() + p2 + !d, pa);
-  size_t in = 1 + convexHullImpl(a, p1, p2 + !d, h, d);
-  return in + convexHullImpl(a, p2 + in * d + 1 - 2 * d, p2 + in * d, h, d);
+  h->insert(h->begin() + p2, pa);
+  size_t in = 1 + convexHullImpl(a, p1, p2, h);
+  return in + convexHullImpl(a, p2 + in - 1, p2 + in, h);
 }
 
 // _____________________________________________________________________________
@@ -1300,13 +1300,16 @@ inline Polygon<T> convexHull(const MultiPoint<T>& l) {
   Point<T> left(std::numeric_limits<T>::max(), 0);
   Point<T> right(std::numeric_limits<T>::lowest(), 0);
   for (const auto& p : l) {
-    if (p.getX() <= left.getX()) left = p;
-    if (p.getX() >= right.getX()) right = p;
+    if (p.getX() < left.getX()) left = p;
+    if (p.getX() > right.getX()) right = p;
   }
 
   Line<T> hull{left, right};
-  convexHullImpl(l, 0, 1, &hull, 1);
-  convexHullImpl(l, 0, hull.size() - 1, &hull, 0);
+  convexHullImpl(l, 0, 1, &hull);
+  hull.push_back(hull.front());
+  convexHullImpl(l, hull.size() - 2, hull.size() - 1, &hull);
+	hull.pop_back();
+
   return Polygon<T>(hull);
 }
 

src/util/tests/lest.h

@@ -31,7 +31,11 @@
 #include <cmath>
 #include <cstddef>
 
-#define  lest_VERSION "1.33.1"
+#define lest_MAJOR  1
+#define lest_MINOR  35
+#define lest_PATCH  1
+
+#define  lest_VERSION  lest_STRINGIFY(lest_MAJOR) "." lest_STRINGIFY(lest_MINOR) "." lest_STRINGIFY(lest_PATCH)
 
 #ifndef  lest_FEATURE_AUTO_REGISTER
 # define lest_FEATURE_AUTO_REGISTER  0
@@ -49,50 +53,55 @@
 # define lest_FEATURE_REGEX_SEARCH  0
 #endif
 
-#ifndef lest_FEATURE_TIME_PRECISION
-#define lest_FEATURE_TIME_PRECISION  0
+#ifndef  lest_FEATURE_TIME_PRECISION
+# define lest_FEATURE_TIME_PRECISION  0
 #endif
 
-#ifndef lest_FEATURE_WSTRING
-#define lest_FEATURE_WSTRING  1
+#ifndef  lest_FEATURE_WSTRING
+# define lest_FEATURE_WSTRING  1
 #endif
 
-#ifdef lest_FEATURE_RTTI
-# define lest__cpp_rtti  lest_FEATURE_RTTI
+#ifdef    lest_FEATURE_RTTI
+# define  lest__cpp_rtti  lest_FEATURE_RTTI
 #elif defined(__cpp_rtti)
-# define lest__cpp_rtti  __cpp_rtti
+# define  lest__cpp_rtti  __cpp_rtti
 #elif defined(__GXX_RTTI) || defined (_CPPRTTI)
-# define lest__cpp_rtti  1
+# define  lest__cpp_rtti  1
 #else
-# define lest__cpp_rtti  0
+# define  lest__cpp_rtti  0
 #endif
 
 #if lest_FEATURE_REGEX_SEARCH
 # include <regex>
 #endif
 
+// Stringify:
+
+#define lest_STRINGIFY(  x )  lest_STRINGIFY_( x )
+#define lest_STRINGIFY_( x )  #x
+
 // Compiler warning suppression:
 
-#ifdef __clang__
+#if defined (__clang__)
 # pragma clang diagnostic ignored "-Waggregate-return"
 # pragma clang diagnostic ignored "-Woverloaded-shift-op-parentheses"
 # pragma clang diagnostic push
 # pragma clang diagnostic ignored "-Wunused-comparison"
-#elif defined __GNUC__
+#elif defined (__GNUC__)
 # pragma GCC   diagnostic ignored "-Waggregate-return"
 # pragma GCC   diagnostic push
 #endif
 
 // Suppress shadow and unused-value warning for sections:
 
-#if defined __clang__
+#if defined (__clang__)
 # define lest_SUPPRESS_WSHADOW    _Pragma( "clang diagnostic push" ) \
                                   _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
 # define lest_SUPPRESS_WUNUSED    _Pragma( "clang diagnostic push" ) \
                                   _Pragma( "clang diagnostic ignored \"-Wunused-value\"" )
 # define lest_RESTORE_WARNINGS    _Pragma( "clang diagnostic pop"  )
 
-#elif defined __GNUC__
+#elif defined (__GNUC__)
 # define lest_SUPPRESS_WSHADOW    _Pragma( "GCC diagnostic push" ) \
                                   _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
 # define lest_SUPPRESS_WUNUSED    _Pragma( "GCC diagnostic push" ) \
@@ -104,12 +113,22 @@
 # define lest_RESTORE_WARNINGS    /*empty*/
 #endif
 
-#ifdef  _MSVC_LANG
-# define lest_CPP17_OR_GREATER_MS (  _MSVC_LANG >= 201703L )
-#else
-# define lest_CPP17_OR_GREATER_MS    0
+// C++ language version detection (C++20 is speculative):
+// Note: VC14.0/1900 (VS2015) lacks too much from C++14.
+
+#ifndef   lest_CPLUSPLUS
+# if defined(_MSVC_LANG ) && !defined(__clang__)
+#  define lest_CPLUSPLUS  (_MSC_VER == 1900 ? 201103L : _MSVC_LANG )
+# else
+#  define lest_CPLUSPLUS  __cplusplus
+# endif
 #endif
-# define lest_CPP17_OR_GREATER    ( __cplusplus >= 201703L ||  lest_CPP17_OR_GREATER_MS )
+
+#define lest_CPP98_OR_GREATER  ( lest_CPLUSPLUS >= 199711L )
+#define lest_CPP11_OR_GREATER  ( lest_CPLUSPLUS >= 201103L )
+#define lest_CPP14_OR_GREATER  ( lest_CPLUSPLUS >= 201402L )
+#define lest_CPP17_OR_GREATER  ( lest_CPLUSPLUS >= 201703L )
+#define lest_CPP20_OR_GREATER  ( lest_CPLUSPLUS >= 202000L )
 
 #if ! defined( lest_NO_SHORT_MACRO_NAMES ) && ! defined( lest_NO_SHORT_ASSERTION_NAMES )
 # define MODULE            lest_MODULE
@@ -186,7 +205,7 @@
             if ( lest::result score = lest_DECOMPOSE( expr ) ) \
                 throw lest::failure{ lest_LOCATION, #expr, score.decomposition }; \
             else if ( lest_env.pass() ) \
-                lest::report( lest_env.os, lest::passing{ lest_LOCATION, #expr, score.decomposition }, lest_env.context() ); \
+                lest::report( lest_env.os, lest::passing{ lest_LOCATION, #expr, score.decomposition, lest_env.zen() }, lest_env.context() ); \
         } \
         catch(...) \
         { \
@@ -201,7 +220,7 @@
             if ( lest::result score = lest_DECOMPOSE( expr ) ) \
             { \
                 if ( lest_env.pass() ) \
-                    lest::report( lest_env.os, lest::passing{ lest_LOCATION, lest::not_expr( #expr ), lest::not_expr( score.decomposition ) }, lest_env.context() ); \
+                    lest::report( lest_env.os, lest::passing{ lest_LOCATION, lest::not_expr( #expr ), lest::not_expr( score.decomposition ), lest_env.zen() }, lest_env.context() ); \
             } \
             else \
                 throw lest::failure{ lest_LOCATION, lest::not_expr( #expr ), lest::not_expr( score.decomposition ) }; \
@@ -381,8 +400,8 @@ struct success : message
 
 struct passing : success
 {
-    passing( location where_, text expr_, text decomposition_ )
-    : success( "passed", where_, expr_ + " for " + decomposition_) {}
+    passing( location where_, text expr_, text decomposition_, bool zen )
+    : success( "passed", where_, expr_ + (zen ? "":" for " + decomposition_) ) {}
 };
 
 struct got_none : success
@@ -524,14 +543,45 @@ inline char const * sfx( char const  * txt ) { return txt; }
 inline char const * sfx( char const  *      ) { return ""; }
 #endif
 
-inline std::string to_string( std::nullptr_t               ) { return "nullptr"; }
-inline std::string to_string( std::string     const & txt ) { return "\"" + txt + "\"" ; }
+inline std::string transformed( char chr )
+{
+    struct Tr { char chr; char const * str; } table[] =
+    {
+        {'\\', "\\\\" },
+        {'\r', "\\r"  }, {'\f', "\\f" },
+        {'\n', "\\n"  }, {'\t', "\\t" },
+    };
+
+    for ( auto tr : table )
+    {
+        if ( chr == tr.chr )
+            return tr.str;
+    }
+
+    auto unprintable = [](char c){ return 0 <= c && c < ' '; };
+
+    auto to_hex_string = [](char c)
+    {
+        std::ostringstream os;
+        os << "\\x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>( static_cast<unsigned char>(c) );
+        return os.str();
+    };
+
+    return unprintable( chr  ) ? to_hex_string( chr ) : std::string( 1, chr );
+}
+
+inline std::string make_tran_string( std::string const & txt ) { std::ostringstream os; for(auto c:txt) os << transformed(c); return os.str(); }
+inline std::string make_strg_string( std::string const & txt ) { return "\"" + make_tran_string(                 txt   ) + "\"" ; }
+inline std::string make_char_string(                char chr ) { return "\'" + make_tran_string( std::string( 1, chr ) ) + "\'" ; }
+
+inline std::string to_string( std::nullptr_t              ) { return "nullptr"; }
+inline std::string to_string( std::string     const & txt ) { return make_strg_string( txt ); }
 #if lest_FEATURE_WSTRING
 inline std::string to_string( std::wstring    const & txt ) ;
 #endif
 
-inline std::string to_string( char    const * const   txt ) { return txt ? to_string( std::string ( txt ) ) : "{null string}"; }
-inline std::string to_string( char          * const   txt ) { return txt ? to_string( std::string ( txt ) ) : "{null string}"; }
+inline std::string to_string( char    const * const   txt ) { return txt ? make_strg_string( txt ) : "{null string}"; }
+inline std::string to_string( char          * const   txt ) { return txt ? make_strg_string( txt ) : "{null string}"; }
 #if lest_FEATURE_WSTRING
 inline std::string to_string( wchar_t const * const   txt ) { return txt ? to_string( std::wstring( txt ) ) : "{null string}"; }
 inline std::string to_string( wchar_t       * const   txt ) { return txt ? to_string( std::wstring( txt ) ) : "{null string}"; }
@@ -550,29 +600,9 @@ inline std::string to_string( unsigned  long long   value ) { return make_value_
 inline std::string to_string(         double        value ) { return make_value_string( value ) ;             }
 inline std::string to_string(          float        value ) { return make_value_string( value ) + sfx("f"  ); }
 
-inline std::string to_string(   signed char           chr ) { return to_string( static_cast<char>( chr ) ); }
-inline std::string to_string( unsigned char           chr ) { return to_string( static_cast<char>( chr ) ); }
-
-inline std::string to_string(          char           chr )
-{
-    struct Tr { char chr; char const * str; } table[] =
-    {
-        {'\r', "'\\r'" }, {'\f', "'\\f'" },
-        {'\n', "'\\n'" }, {'\t', "'\\t'" },
-    };
-
-    for ( auto tr : table )
-    {
-        if ( chr == tr.chr )
-            return tr.str;
-    }
-
-    auto unprintable = [](char c){ return 0 <= c && c < ' '; };
-
-    return unprintable( chr  )
-        ? to_string( static_cast<unsigned int>( chr ) )
-        : "\'" + std::string( 1, chr ) + "\'" ;
-}
+inline std::string to_string(   signed char           chr ) { return make_char_string( static_cast<char>( chr ) ); }
+inline std::string to_string( unsigned char           chr ) { return make_char_string( static_cast<char>( chr ) ); }
+inline std::string to_string(          char           chr ) { return make_char_string(                    chr   ); }
 
 template< typename T >
 struct is_streamable
@@ -968,7 +998,7 @@ inline bool select( text name, texts include )
 
 inline int indefinite( int repeat ) { return repeat == -1; }
 
-using seed_t = unsigned long;
+using seed_t = std::mt19937::result_type;
 
 struct options
 {
@@ -979,6 +1009,7 @@ struct options
     bool tags    = false;
     bool time    = false;
     bool pass    = false;
+    bool zen     = false;
     bool lexical = false;
     bool random  = false;
     bool verbose = false;
@@ -999,12 +1030,14 @@ struct env
 
     env & operator()( text test )
     {
-        testing = test; return *this;
+        clear(); testing = test; return *this;
     }
 
     bool abort() { return opt.abort; }
     bool pass()  { return opt.pass; }
+    bool zen()   { return opt.zen; }
 
+    void clear() { ctx.clear(); }
     void pop()   { ctx.pop_back(); }
     void push( text proposition ) { ctx.emplace_back( proposition ); }
 
@@ -1311,6 +1344,7 @@ inline auto split_arguments( texts args ) -> std::tuple<options, texts>
             else if ( opt == "-l"      || "--list-tests" == opt ) { option.list    =  true; continue; }
             else if ( opt == "-t"      || "--time"       == opt ) { option.time    =  true; continue; }
             else if ( opt == "-p"      || "--pass"       == opt ) { option.pass    =  true; continue; }
+            else if ( opt == "-z"      || "--pass-zen"   == opt ) { option.zen     =  true; continue; }
             else if ( opt == "-v"      || "--verbose"    == opt ) { option.verbose =  true; continue; }
             else if (                     "--version"    == opt ) { option.version =  true; continue; }
             else if ( opt == "--order" && "declared"     == val ) { /* by definition */   ; continue; }
@@ -1322,6 +1356,8 @@ inline auto split_arguments( texts args ) -> std::tuple<options, texts>
         }
         in.push_back( arg );
     }
+    option.pass = option.pass || option.zen;
+
     return std::make_tuple( option, in );
 }
 
@@ -1337,6 +1373,7 @@ inline int usage( std::ostream & os )
         "  -g, --list-tags    list tags of selected tests\n"
         "  -l, --list-tests   list selected tests\n"
         "  -p, --pass         also report passing tests\n"
+        "  -z, --pass-zen     ... without expansion\n"
         "  -t, --time         list duration of selected tests\n"
         "  -v, --verbose      also report passing or failing sections\n"
         "  --order=declared   use source code test order (default)\n"
@@ -1437,9 +1474,9 @@ int run( test const (&specification)[N], int argc, char * argv[], std::ostream &
 
 } // namespace lest
 
-#ifdef __clang__
+#if defined (__clang__)
 # pragma clang diagnostic pop
-#elif defined __GNUC__
+#elif defined (__GNUC__)
 # pragma GCC   diagnostic pop
 #endif