changes

.ycm_extra_conf.py

@@ -0,0 +1,195 @@
+# This file is NOT licensed under the GPLv3, which is the license for the rest
+# of YouCompleteMe.
+#
+# Here's the license text for this file:
+#
+# This is free and unencumbered software released into the public domain.
+#
+# Anyone is free to copy, modify, publish, use, compile, sell, or
+# distribute this software, either in source code form or as a compiled
+# binary, for any purpose, commercial or non-commercial, and by any
+# means.
+#
+# In jurisdictions that recognize copyright laws, the author or authors
+# of this software dedicate any and all copyright interest in the
+# software to the public domain. We make this dedication for the benefit
+# of the public at large and to the detriment of our heirs and
+# successors. We intend this dedication to be an overt act of
+# relinquishment in perpetuity of all present and future rights to this
+# software under copyright law.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+# For more information, please refer to <http://unlicense.org/>
+
+import os
+import ycm_core
+
+# These are the compilation flags that will be used in case there's no
+# compilation database set (by default, one is not set).
+# CHANGE THIS LIST OF FLAGS. YES, THIS IS THE DROID YOU HAVE BEEN LOOKING FOR.
+flags = [
+'-Wall',
+'-Wextra',
+'-Werror',
+'-Wno-c++98-compat',
+'-Wno-long-long',
+'-Wno-variadic-macros',
+'-fexceptions',
+'-DNDEBUG',
+# You 100% do NOT need -DUSE_CLANG_COMPLETER in your flags; only the YCM
+# source code needs it.
+'-DUSE_CLANG_COMPLETER',
+# THIS IS IMPORTANT! Without a "-std=<something>" flag, clang won't know which
+# language to use when compiling headers. So it will guess. Badly. So C++
+# headers will be compiled as C headers. You don't want that so ALWAYS specify
+# a "-std=<something>".
+# For a C project, you would set this to something like 'c99' instead of
+# 'c++11'.
+'-std=c++11',
+# ...and the same thing goes for the magic -x option which specifies the
+# language that the files to be compiled are written in. This is mostly
+# relevant for c++ headers.
+# For a C project, you would set this to 'c' instead of 'c++'.
+'-x',
+'c++',
+'-isystem',
+'../BoostParts',
+'-isystem',
+# This path will only work on OS X, but extra paths that don't exist are not
+# harmful
+'/System/Library/Frameworks/Python.framework/Headers',
+'-isystem',
+'../llvm/include',
+'-isystem',
+'../llvm/tools/clang/include',
+'-I',
+'.',
+'-I',
+'./ClangCompleter',
+'-isystem',
+'./tests/gmock/gtest',
+'-isystem',
+'./tests/gmock/gtest/include',
+'-isystem',
+'./tests/gmock',
+'-isystem',
+'./tests/gmock/include'
+'-I',
+'/usr/lib/gcc/x86_64-linux-gnu/4.8/include/',
+'-I',
+'/usr/lib/gcc/x86_64-linux-gnu/5/include/',
+'-I',
+'/usr/lib/gcc/x86_64-linux-gnu/6/include/',
+'-fopenmp'
+]
+
+
+# Set this to the absolute path to the folder (NOT the file!) containing the
+# compile_commands.json file to use that instead of 'flags'. See here for
+# more details: http://clang.llvm.org/docs/JSONCompilationDatabase.html
+#
+# You can get CMake to generate this file for you by adding:
+#   set( CMAKE_EXPORT_COMPILE_COMMANDS 1 )
+# to your CMakeLists.txt file.
+#
+# Most projects will NOT need to set this to anything; you can just change the
+# 'flags' list of compilation flags. Notice that YCM itself uses that approach.
+compilation_database_folder = 'build'
+
+if os.path.exists( compilation_database_folder ):
+  database = ycm_core.CompilationDatabase( compilation_database_folder )
+else:
+  database = None
+
+SOURCE_EXTENSIONS = [ '.cpp', '.cxx', '.cc', '.c', '.m', '.mm' ]
+
+def DirectoryOfThisScript():
+  return os.path.dirname( os.path.abspath( __file__ ) )
+
+
+def MakeRelativePathsInFlagsAbsolute( flags, working_directory ):
+  if not working_directory:
+    return list( flags )
+  new_flags = []
+  make_next_absolute = False
+  path_flags = [ '-isystem', '-I', '-iquote', '--sysroot=' ]
+  for flag in flags:
+    new_flag = flag
+
+    if make_next_absolute:
+      make_next_absolute = False
+      if not flag.startswith( '/' ):
+        new_flag = os.path.join( working_directory, flag )
+
+    for path_flag in path_flags:
+      if flag == path_flag:
+        make_next_absolute = True
+        break
+
+      if flag.startswith( path_flag ):
+        path = flag[ len( path_flag ): ]
+        new_flag = path_flag + os.path.join( working_directory, path )
+        break
+
+    if new_flag:
+      new_flags.append( new_flag )
+  return new_flags
+
+
+def IsHeaderFile( filename ):
+  extension = os.path.splitext( filename )[ 1 ]
+  return extension in [ '.h', '.hxx', '.hpp', '.hh' ]
+
+
+def GetCompilationInfoForFile( filename ):
+  # The compilation_commands.json file generated by CMake does not have entries
+  # for header files. So we do our best by asking the db for flags for a
+  # corresponding source file, if any. If one exists, the flags for that file
+  # should be good enough.
+  if IsHeaderFile( filename ):
+    basename = os.path.splitext( filename )[ 0 ]
+    for extension in SOURCE_EXTENSIONS:
+      replacement_file = basename + extension
+      if os.path.exists( replacement_file ):
+        compilation_info = database.GetCompilationInfoForFile(
+          replacement_file )
+        if compilation_info.compiler_flags_:
+          return compilation_info
+    return None
+  return database.GetCompilationInfoForFile( filename )
+
+
+def FlagsForFile( filename, **kwargs ):
+  if database:
+    # Bear in mind that compilation_info.compiler_flags_ does NOT return a
+    # python list, but a "list-like" StringVec object
+    compilation_info = GetCompilationInfoForFile( filename )
+    if not compilation_info:
+      return None
+
+    final_flags = MakeRelativePathsInFlagsAbsolute(
+      compilation_info.compiler_flags_,
+      compilation_info.compiler_working_dir_ )
+
+    # NOTE: This is just for YouCompleteMe; it's highly likely that your project
+    # does NOT need to remove the stdlib flag. DO NOT USE THIS IN YOUR
+    # ycm_extra_conf IF YOU'RE NOT 100% SURE YOU NEED IT.
+    try:
+      final_flags.remove( '-stdlib=libc++' )
+    except ValueError:
+      pass
+  else:
+    relative_to = DirectoryOfThisScript()
+    final_flags = MakeRelativePathsInFlagsAbsolute( flags, relative_to )
+
+  return {
+    'flags': final_flags,
+    'do_cache': True
+  }

src/osmfixer/index/StatIdx.cpp

@@ -12,6 +12,7 @@
 using osmfixer::StatIdx;
 using osmfixer::OsmAttrs;
 using osmfixer::Station;
+using osmfixer::Group;
 
 // _____________________________________________________________________________
 void StatIdx::readFromFile(const std::string& path) {
@@ -25,41 +26,117 @@ void StatIdx::readFromFile(const std::string& path) {
     if (line.size() == 0) break;
 
     std::stringstream rec(line);
-    size_t osmid;
+    size_t osmid, group;
     double lat, lng;
     OsmAttrs attrs;
 
     rec >> osmid;
     rec >> lat;
     rec >> lng;
+    rec >> group;
 
-    addStation(osmid, lat, lng, attrs);
+    addStation(osmid, lat, lng, group, attrs);
   }
 
-  initIndex();
+  // second, parse groups
+  while (std::getline(f, line)) {
+    // empty line is separator between blocks
+    if (line.size() == 0) break;
+
+    std::stringstream rec(line);
+    size_t osmid;
+    OsmAttrs attrs;
+
+    rec >> osmid;
 
-  std::cout << util::geo::getWKT(_bbox) << std::endl;
+    addGroup(osmid, attrs);
+  }
+
+  initGroups();
+  initIndex();
 }
 
 // _____________________________________________________________________________
-void StatIdx::addStation(size_t osmid, double lat, double lng,
+void StatIdx::addStation(size_t osmid, double lat, double lng, size_t group,
                          const OsmAttrs& attrs) {
   std::cout << "Record: " << osmid << " " << lat << " " << lng << std::endl;
   auto point = util::geo::latLngToWebMerc<double>(lat, lng);
 
-  _stations.emplace_back(Station{osmid, point, attrs});
+  _stations.emplace_back(Station{osmid, group, point, attrs});
 
   // extend bounding box
   _bbox = util::geo::extendBox(point, _bbox);
 }
 
 // _____________________________________________________________________________
+void StatIdx::addGroup(size_t osmid, const OsmAttrs& attrs) {
+  std::cout << osmid << std::endl;
+  Group g;
+  g.osmid = osmid;
+  g.attrs = attrs;
+  _groups.emplace_back(g);
+}
+
+// _____________________________________________________________________________
+void StatIdx::initGroups() {
+  for (size_t i = 0; i < _stations.size(); i++) {
+    // this should be ensured by the input file
+    assert(_stations[i].group < _groups.size());
+    _groups[_stations[i].group].stations.push_back(i);
+  }
+
+  for (size_t i = 0; i < _groups.size(); i++) {
+    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++) {
+        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(_stations[stid].pos.getX() + x,
+                                       _stations[stid].pos.getY() + y));
+      }
+    }
+    _groups[i].poly = util::geo::convexHull(mp);
+  }
+}
+
+// _____________________________________________________________________________
 void StatIdx::initIndex() {
-  _grid = util::geo::Grid<size_t, util::geo::Point, double>(5000, 5000, _bbox,
-                                                            false);
+  _sgrid = util::geo::Grid<size_t, util::geo::Point, double>(5000, 5000, _bbox,
+                                                             false);
+  _ggrid = util::geo::Grid<size_t, util::geo::Polygon, double>(5000, 5000,
+                                                               _bbox, false);
   for (size_t i = 0; i < _stations.size(); i++) {
-    _grid.add(_stations[i].pos, i);
+    _sgrid.add(_stations[i].pos, i);
+  }
+
+  for (size_t i = 0; i < _groups.size(); i++) {
+    _ggrid.add(_groups[i].poly, i);
+  }
+}
+
+// _____________________________________________________________________________
+std::vector<const Group*> StatIdx::getGroups(const util::geo::DBox bbox) const {
+  std::vector<const Group*> 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);
+  _ggrid.get(reqBox, &tmp);
+
+  for (auto i : tmp) {
+    if (util::geo::intersects(_groups[i].poly, reqBox))
+      ret.push_back(&_groups[i]);
   }
+
+  return ret;
 }
 
 // _____________________________________________________________________________
@@ -73,7 +150,7 @@ std::vector<const Station*> StatIdx::getStations(
 
   std::set<size_t> tmp;
   auto reqBox = util::geo::DBox(ll, ur);
-  _grid.get(reqBox, &tmp);
+  _sgrid.get(reqBox, &tmp);
 
   for (auto i : tmp) {
     if (util::geo::contains(_stations[i].pos, reqBox))

src/osmfixer/index/StatIdx.h

@@ -17,10 +17,18 @@ typedef std::map<std::string, std::vector<std::string>> OsmAttrs;
 
 struct Station {
   size_t osmid;
+  size_t group;
   util::geo::DPoint pos;
   OsmAttrs attrs;
 };
 
+struct Group {
+  size_t osmid;
+  util::geo::DPolygon poly;
+  OsmAttrs attrs;
+  std::vector<size_t> stations;
+};
+
 class StatIdx {
  public:
   StatIdx() {}
@@ -28,17 +36,23 @@ class StatIdx {
   void readFromFile(const std::string& path);
 
   std::vector<const Station*> getStations(const util::geo::DBox bbox) const;
+  std::vector<const Group*> getGroups(const util::geo::DBox bbox) const;
 
  private:
-  void addStation(size_t id, double lat, double lng, const OsmAttrs& attrs);
+  void addStation(size_t id, double lat, double lng, size_t group,
+                  const OsmAttrs& attrs);
+  void addGroup(size_t id, const OsmAttrs& attrs);
 
   void initIndex();
+  void initGroups();
 
   std::vector<Station> _stations;
+  std::vector<Group> _groups;
   util::geo::DBox _bbox;
 
-  util::geo::Grid<size_t, util::geo::Point, double> _grid;
+  util::geo::Grid<size_t, util::geo::Point, double> _sgrid;
+  util::geo::Grid<size_t, util::geo::Polygon, double> _ggrid;
 };
-}
+}  // namespace osmfixer
 
-#endif
+#endif  // OSMFIXER_INDEX_STATIDX_H_

src/osmfixer/server/StatServer.cpp

@@ -2,12 +2,12 @@
 // Chair of Algorithms and Data Structures.
 // Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
 
+#include <vector>
 #include "osmfixer/server/StatServer.h"
 #include "util/Misc.h"
 #include "util/String.h"
 #include "util/geo/Geo.h"
 #include "util/log/Log.h"
-#include "util/String.h"
 
 using osmfixer::StatServer;
 using osmfixer::Params;
@@ -51,8 +51,7 @@ 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, ',');
 
-  if (box.size() != 4)
-    throw std::invalid_argument("Invalid request.");
+  if (box.size() != 4) throw std::invalid_argument("Invalid request.");
 
   double lat1 = atof(box[0].c_str());
   double lng1 = atof(box[1].c_str());
@@ -61,18 +60,37 @@ util::http::Answer StatServer::handleMapReq(const Params& pars) const {
 
   std::cout << pars.find("bbox")->second << std::endl;
 
-  util::geo::DBox bbox(util::geo::DPoint(lng1, lat1), util::geo::DPoint(lng2, lat2));
+  util::geo::DBox bbox(util::geo::DPoint(lat1, lng1),
+                       util::geo::DPoint(lat2, lng2));
 
   LOG(INFO) << "Request for bounding box " << util::geo::getWKT(bbox);
 
   std::stringstream json;
 
+  json << std::setprecision(10);
+
   if (cb.size()) json << cb << "(";
-  json << "[";
+  json << "{\"stats\":[";
+
+  auto ret = _idx->getStations(bbox);
+  char sep = ' ';
+  for (auto stat : ret) {
+    json << sep;
+    sep = ',';
+    printStation(stat, &json);
+  }
 
-  // TODO: query index
+  json << "], \"groups\":[";
+  auto gret = _idx->getGroups(bbox);
+  sep = ' ';
+  for (auto group : gret) {
+    json << sep;
+    sep = ',';
+    printGroup(group, &json);
+  }
+
+  json << "]}";
 
-  json << "]";
   if (cb.size()) json << ")";
 
   auto answ = util::http::Answer("200 OK", json.str(), true);
@@ -82,6 +100,30 @@ 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\":"
+         << latLng.getY() << ",\"lon\":" << latLng.getX() << "}";
+}
+
+// _____________________________________________________________________________
+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->osmid << ",\"poly\":[";
+  char sep = ' ';
+  for (auto p : projPoly) {
+    (*out) << sep << "[" << p.getY() << "," << p.getX() << "]";
+    sep = ',';
+  }
+  (*out) << "]}";
+}
+
+// _____________________________________________________________________________
 std::string StatServer::parseUrl(std::string u, std::string pl,
                                  std::map<std::string, std::string>* params) {
   auto parts = util::split(u, '?');

src/osmfixer/server/StatServer.h

@@ -5,6 +5,8 @@
 #ifndef OSMFIXER_SERVER_STATSERVER_H_
 #define OSMFIXER_SERVER_STATSERVER_H_
 
+#include <map>
+#include <string>
 #include "osmfixer/index/StatIdx.h"
 #include "util/http/Server.h"
 
@@ -14,7 +16,7 @@ typedef std::map<std::string, std::string> Params;
 
 class StatServer : public util::http::Handler {
  public:
-  StatServer(const osmfixer::StatIdx* idx) : _idx(idx) {}
+  explicit StatServer(const osmfixer::StatIdx* idx) : _idx(idx) {}
 
   virtual util::http::Answer handle(const util::http::Req& request,
                                     int connection) const;
@@ -24,8 +26,11 @@ class StatServer : public util::http::Handler {
 
   util::http::Answer handleMapReq(const Params& pars) const;
 
+  static void printStation(const Station* stat, std::ostream* out);
+  static void printGroup(const Group* stat, std::ostream* out);
+
   const osmfixer::StatIdx* _idx;
 };
-}
+}  // namespace osmfixer
 
-#endif
+#endif  // OSMFIXER_SERVER_STATSERVER_H_

src/util/geo/Geo.h

@@ -243,15 +243,21 @@ inline bool doubleEq(double a, double b) { return fabs(a - b) < EPSILON; }
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Point<T>& p, const Box<T>& box) {
-  return p.getX() >= box.getLowerLeft().getX() &&
-         p.getX() <= box.getUpperRight().getX() &&
-         p.getY() >= box.getLowerLeft().getY() &&
-         p.getY() <= box.getUpperRight().getY();
+  // check if point lies in box
+  return (fabs(p.getX() - box.getLowerLeft().getX()) < EPSILON ||
+          p.getX() > box.getLowerLeft().getX()) &&
+         (fabs(p.getX() - box.getUpperRight().getX()) < EPSILON ||
+          p.getX() < box.getUpperRight().getX()) &&
+         (fabs(p.getY() - box.getLowerLeft().getY()) < EPSILON ||
+          p.getY() > box.getLowerLeft().getY()) &&
+         (fabs(p.getY() - box.getUpperRight().getY()) < EPSILON ||
+          p.getY() < box.getUpperRight().getY());
 }
 
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Line<T>& l, const Box<T>& box) {
+  // check if line lies in box
   for (const auto& p : l)
     if (!contains(p, box)) return false;
   return true;
@@ -260,24 +266,35 @@ inline bool contains(const Line<T>& l, const Box<T>& box) {
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const LineSegment<T>& l, const Box<T>& box) {
+  // check if line segment lies in box
   return contains(l.first, box) && contains(l.second, box);
 }
 
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Box<T>& b, const Box<T>& box) {
+  // check if box b lies in box
   return contains(b.getLowerLeft(), box) && contains(b.getUpperRight(), box);
 }
 
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Point<T>& p, const LineSegment<T>& ls) {
+  // check if point p lies in (on) line segment ls
   return fabs(crossProd(p, ls)) < EPSILON && contains(p, getBoundingBox(ls));
 }
 
 // _____________________________________________________________________________
 template <typename T>
+inline bool contains(const LineSegment<T>& a, const LineSegment<T>& b) {
+  // check if line segment a is contained in line segment b
+  return contains(a.first, b) && contains(a.second, b);
+}
+
+// _____________________________________________________________________________
+template <typename T>
 inline bool contains(const Point<T>& p, const Line<T>& l) {
+  // check if point p lies in line l
   for (size_t i = 1; i < l.size(); i++) {
     if (contains(p, LineSegment<T>(l[i - 1], l[i]))) return true;
   }
@@ -287,6 +304,8 @@ inline bool contains(const Point<T>& p, const Line<T>& l) {
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Point<T>& p, const Polygon<T>& poly) {
+  // check if point p lies in polygon
+
   // see https://de.wikipedia.org/wiki/Punkt-in-Polygon-Test_nach_Jordan
   int8_t c = -1;
 
@@ -328,19 +347,53 @@ inline int8_t polyContCheck(const Point<T>& a, Point<T> b, Point<T> c) {
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Polygon<T>& polyC, const Polygon<T>& poly) {
-  for (const auto& p : polyC.getOuter()) {
-    if (!contains(p, poly)) {
+  // check if polygon polyC lies in polygon poly
+
+  for (size_t i = 1; i < polyC.getOuter().size(); i++) {
+    if (!contains(LineSegment<T>(polyC.getOuter()[i - 1], polyC.getOuter()[i]),
+                  poly))
+      return false;
+  }
+
+  // also check the last hop
+  if (!contains(LineSegment<T>(polyC.getOuter().back(), polyC.getOuter().front()),
+                poly))
+    return false;
+
+  return true;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline bool contains(const LineSegment<T>& ls, const Polygon<T>& p) {
+  // check if linesegment ls lies in polygon poly
+
+  // if one of the endpoints lies outside, abort
+  if (!contains(ls.first, p)) return false;
+  if (!contains(ls.second, p)) return false;
+
+  for (size_t i = 1; i < p.getOuter().size(); i++) {
+    auto seg = LineSegment<T>(p.getOuter()[i - 1], p.getOuter()[i]);
+    if (!(contains(ls.first, seg) || contains(ls.second, seg)) &&
+        intersects(seg, ls)) {
       return false;
     }
   }
+
+  auto seg = LineSegment<T>(p.getOuter().back(), p.getOuter().front());
+  if (!(contains(ls.first, seg) || contains(ls.second, seg)) &&
+      intersects(seg, ls)) {
+    return false;
+  }
+
   return true;
 }
 
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Line<T>& l, const Polygon<T>& poly) {
-  for (const auto& p : l) {
-    if (!contains(p, poly)) {
+  for (size_t i = 1; i < l.size(); i++) {
+    if (!contains(LineSegment<T>(l[i - 1], l[i]), poly)) {
       return false;
     }
   }
@@ -351,9 +404,7 @@ inline bool contains(const Line<T>& l, const Polygon<T>& poly) {
 template <typename T>
 inline bool contains(const Line<T>& l, const Line<T>& other) {
   for (const auto& p : l) {
-    if (!contains(p, other)) {
-      return false;
-    }
+    if (!contains(p, other)) return false;
   }
   return true;
 }
@@ -361,17 +412,13 @@ inline bool contains(const Line<T>& l, const Line<T>& other) {
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Box<T>& b, const Polygon<T>& poly) {
-  return contains(b.getLowerLeft(), poly) &&
-         contains(b.getUpperRight(), poly) &&
-         contains(Point<T>(b.getUpperRight().getX(), b.getLowerLeft().getY()),
-                  poly) &&
-         contains(Point<T>(b.getLowerLeft().getX(), b.getUpperRight().getY()),
-                  poly);
+  return contains(convexHull(b), poly);
 }
 
 // _____________________________________________________________________________
 template <typename T>
 inline bool contains(const Polygon<T>& poly, const Box<T>& b) {
+  // check of poly lies in box
   for (const auto& p : poly.getOuter()) {
     if (!contains(p, b)) return false;
   }
@@ -400,6 +447,8 @@ inline bool contains(const std::vector<GeometryA<T>>& multigeo,
 // _____________________________________________________________________________
 template <typename T>
 inline bool intersects(const LineSegment<T>& ls1, const LineSegment<T>& ls2) {
+  // check if two linesegments intersect
+
   // two line segments intersect of there is a single, well-defined intersection
   // point between them. If more than 1 endpoint is colinear with any line,
   // the segments have infinite intersections. We handle this case as non-
@@ -470,6 +519,39 @@ inline bool intersects(const Box<T>& b1, const Box<T>& b2) {
 
 // _____________________________________________________________________________
 template <typename T>
+inline bool intersects(const Box<T>& b, const Polygon<T>& poly) {
+  return intersects(b, poly);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline bool intersects(const Polygon<T>& poly, const Box<T>& b) {
+  if (intersects(
+          LineSegment<T>(b.getLowerLeft(), Point<T>(b.getUpperRight().getX(),
+                                                    b.getLowerLeft().getY())),
+          poly))
+    return true;
+  if (intersects(
+          LineSegment<T>(b.getLowerLeft(), Point<T>(b.getLowerLeft().getX(),
+                                                    b.getUpperRight().getY())),
+          poly))
+    return true;
+  if (intersects(
+          LineSegment<T>(b.getUpperRight(), Point<T>(b.getLowerLeft().getX(),
+                                                     b.getUpperRight().getY())),
+          poly))
+    return true;
+  if (intersects(
+          LineSegment<T>(b.getUpperRight(), Point<T>(b.getUpperRight().getX(),
+                                                     b.getLowerLeft().getY())),
+          poly))
+    return true;
+
+  return contains(poly, b) || contains(b, poly);
+}
+
+// _____________________________________________________________________________
+template <typename T>
 inline bool intersects(const LineSegment<T>& ls, const Box<T>& b) {
   if (intersects(ls, LineSegment<T>(b.getLowerLeft(),
                                     Point<T>(b.getUpperRight().getX(),
@@ -499,6 +581,7 @@ inline bool intersects(const LineSegment<T>& ls, const Polygon<T>& p) {
       return true;
   }
 
+  // also check the last hop
   if (intersects(LineSegment<T>(p.getOuter().back(), p.getOuter().front()), ls))
     return true;
 

src/util/tests/TestMain.cpp

@@ -1446,6 +1446,26 @@ CASE("geometry") {
   EXPECT(geo::dist(Line<double>{{7, 7}, {7, -7}, {-7, -7}, {-7, 7}, {9, 0}, {-9, 0}, {0, 9}, {0, -9}}, Point<double>{7, 4}) == approx(0));
   EXPECT(geo::dist(Line<double>{{0, 0}, {1, 1}, {2, 0}}, Line<double>{{1.5, 0.5}, {1.5, 100}}) == approx(0));
   EXPECT(geo::dist(Line<double>{{0, 0}, {1, 1}, {2, 0}}, Line<double>{{2, 0.5}, {2, 100}}) == approx(0.353553));
+
+  EXPECT(geo::contains(util::geo::Point<double>{1.5, 0.5}, util::geo::LineSegment<double>{{1, 1},{1.5, 0.5}}));
+  EXPECT(geo::contains(util::geo::Point<double>{1.5, 0.5}, util::geo::LineSegment<double>{{1, 1},{1.5, 0.5}}));
+
+  auto polyTest = geo::Polygon<double>({{1, 1}, {3, 1}, {2, 2}, {3, 3}, {1, 3}});
+  EXPECT(!geo::contains(util::geo::LineSegment<double>({2.5, 1.3}, {2.5, 2.6}), polyTest));
+
+  EXPECT(!geo::contains(util::geo::LineSegment<double>{{2.5, 1.3}, {2.5, 2.6}}, polyTest));
+  EXPECT(geo::contains(util::geo::LineSegment<double>{{2.5, 2.6}, {1.5, 2}}, polyTest));
+  EXPECT(!geo::contains(util::geo::Line<double>{{2.5, 1.3}, {2.5, 2.6}, {1.5, 2}}, polyTest));
+  EXPECT(geo::contains(util::geo::Line<double>{{2.5, 1.3}, {1.5, 2}, {2.5, 2.6}}, polyTest));
+
+  EXPECT(!geo::contains(util::geo::Box<double>{{1, 1},{2.5, 2.6}}, polyTest));
+
+  EXPECT(geo::intersects(Box<double>(Point<double>(0, 0), Point<double>(10, 10)), Box<double>(Point<double>(2, 2), Point<double>(8, 8))));
+  EXPECT(geo::intersects(Box<double>(Point<double>(0, 0), Point<double>(10, 10)), Box<double>(Point<double>(-2, -2), Point<double>(8, 8))));
+  EXPECT(geo::intersects(Box<double>(Point<double>(0, 0), Point<double>(10, 10)), Box<double>(Point<double>(-2, -2), Point<double>(12, 12))));
+  EXPECT(geo::intersects(Box<double>(Point<double>(0, 0), Point<double>(10, 10)), Box<double>(Point<double>(5, 5), Point<double>(12, 12))));
+
+  EXPECT(!geo::intersects(Box<double>(Point<double>(0, 0), Point<double>(10, 10)), Box<double>(Point<double>(15, 15), Point<double>(12, 12))));
 }
 
 }};