Fix splitter so that cells below the origin have the correct index.

Add tests for the above.
ALSO - Store viewMap across point view processing so that cells are merged
  from multiple point views.
Close #1336

filters/splitter/SplitterFilter.cpp

@@ -51,6 +51,9 @@ static PluginInfo const s_info = PluginInfo(
 
 CREATE_STATIC_PLUGIN(1, 0, SplitterFilter, Filter, s_info)
 
+SplitterFilter::SplitterFilter() : m_viewMap(CoordCompare())
+{}
+
 std::string SplitterFilter::getName() const { return s_info.name; }
 
 void SplitterFilter::addArgs(ProgramArgs& args)
@@ -64,6 +67,7 @@ void SplitterFilter::addArgs(ProgramArgs& args)
 
 
 //This used to be a lambda, but the VS compiler exploded, I guess.
+/**
 typedef std::pair<int, int> Coord;
 namespace
 {
@@ -79,16 +83,14 @@ class CoordCompare
     };
 };
 }
+**/
 
 PointViewSet SplitterFilter::run(PointViewPtr inView)
 {
     PointViewSet viewSet;
     if (!inView->size())
         return viewSet;
 
-    CoordCompare compare;
-    std::map<Coord, PointViewPtr, CoordCompare> viewMap(compare);
-
     // Use the location of the first point as the origin, unless specified.
     // (!= test == isnan(), which doesn't exist on windows)
     if (m_xOrigin != m_xOrigin)
@@ -101,20 +103,27 @@ PointViewSet SplitterFilter::run(PointViewPtr inView)
     for (PointId idx = 0; idx < inView->size(); idx++)
     {
         double x = inView->getFieldAs<double>(Dimension::Id::X, idx);
-        int xpos = (x - m_xOrigin) / m_length;
+        x -= m_xOrigin;
+        int xpos = x / m_length;
+        if (x < 0)
+            xpos--;
+
         double y = inView->getFieldAs<double>(Dimension::Id::Y, idx);
-        int ypos = (y - m_yOrigin) / m_length;
+        y -= m_yOrigin;
+        int ypos = y / m_length;
+        if (y < 0)
+            ypos--;
 
         Coord loc(xpos, ypos);
-        PointViewPtr& outView = viewMap[loc];
+        PointViewPtr& outView = m_viewMap[loc];
         if (!outView)
             outView = inView->makeNew();
         outView->appendPoint(*inView.get(), idx);
     }
 
     // Pull the buffers out of the map and stick them in the standard
-    // output set, setting the bounds as we go.
-    for (auto bi = viewMap.begin(); bi != viewMap.end(); ++bi)
+    // output set.
+    for (auto bi = m_viewMap.begin(); bi != m_viewMap.end(); ++bi)
         viewSet.insert(bi->second);
     return viewSet;
 }

filters/splitter/SplitterFilter.hpp

@@ -45,9 +45,23 @@ namespace pdal
 
 class PDAL_DLL SplitterFilter : public pdal::Filter
 {
+private:
+    //This used to be a lambda, but the VS compiler exploded, I guess.
+    typedef std::pair<int, int> Coord;
+    class CoordCompare
+    {
+    public:
+        bool operator () (const Coord& c1, const Coord& c2) const
+        {
+            return c1.first < c2.first ? true :
+                c1.first > c2.first ? false :
+                c1.second < c2.second ? true :
+                false;
+        };
+    };
+
 public:
-    SplitterFilter() : Filter()
-        {}
+    SplitterFilter();
 
     static void * create();
     static int32_t destroy(void *);
@@ -57,6 +71,7 @@ class PDAL_DLL SplitterFilter : public pdal::Filter
     double m_length;
     double m_xOrigin;
     double m_yOrigin;
+    std::map<Coord, PointViewPtr, CoordCompare> m_viewMap;
 
     virtual void addArgs(ProgramArgs& args);
     virtual PointViewSet run(PointViewPtr view);

test/unit/filters/SplitterTest.cpp

@@ -76,25 +76,37 @@ TEST(SplitterTest, test_tile_filter)
     StageWrapper::done(s, table);
 
     std::vector<PointViewPtr> views;
-    for (auto it = viewSet.begin(); it != viewSet.end(); ++it)
-        views.push_back(*it);
+    std::map<PointViewPtr, BOX2D> bounds;
 
-    auto sorter = [](PointViewPtr p1, PointViewPtr p2)
+    for (auto it = viewSet.begin(); it != viewSet.end(); ++it)
     {
-        BOX2D b1, b2;
+        BOX2D b;
+        PointViewPtr v = *it;
+        v->calculateBounds(b);
+        EXPECT_TRUE(b.maxx - b.minx <= 1000);    
+        EXPECT_TRUE(b.maxy - b.miny <= 1000);    
+
+        for (auto& p : bounds)
+            EXPECT_FALSE(p.second.overlaps(b));
 
-        p1->calculateBounds(b1);
-        p2->calculateBounds(b2);
+        bounds[v] = b;
+        views.push_back(v);
+    }
+
+    auto sorter = [&bounds](PointViewPtr p1, PointViewPtr p2)
+    {
+        BOX2D b1 = bounds[p1];
+        BOX2D b2 = bounds[p2];
 
         return b1.minx < b2.minx ?  true :
             b1.minx > b2.minx ? false :
             b1.miny < b2.miny;
     };
     std::sort(views.begin(), views.end(), sorter);
 
-    EXPECT_EQ(views.size(), 15u);
-    size_t counts[] = {24, 27, 26, 27, 10, 166, 142, 76, 141, 132, 63, 70, 67,
-        34, 60 };
+    EXPECT_EQ(views.size(), 24u);
+    size_t counts[] = {24, 25, 2, 26, 27, 10, 82, 68, 43, 57, 7, 71, 73,
+        61, 33, 84, 74, 4, 59, 70, 67, 34, 60, 4 };
     for (size_t i = 0; i < views.size(); ++i)
     {
         PointViewPtr view = views[i];