From dc48725c1f54cb30649eea93691d8c5e0711c9c4 Mon Sep 17 00:00:00 2001
From: Andrew Bell <andrew.bell.ia@gmail.com>
Date: Wed, 7 Oct 2015 11:47:40 -0500
Subject: [PATCH] Small bug fixes in attribute filter. Make crop filter work
 when prepared more than once. Add tests for attribute filter. Remove
 multi-dimension support for attribute filter.

---
 filters/crop/CropFilter.cpp                   |  13 +-
 plugins/attribute/CMakeLists.txt              |   4 +
 plugins/attribute/filters/AttributeFilter.cpp | 185 ++++++++---------
 plugins/attribute/filters/AttributeFilter.hpp |  68 ++-----
 .../attribute/test/AttributeFilterTest.cpp    | 186 ++++++++++++++++++
 5 files changed, 300 insertions(+), 156 deletions(-)
 create mode 100644 plugins/attribute/test/AttributeFilterTest.cpp

diff --git a/filters/crop/CropFilter.cpp b/filters/crop/CropFilter.cpp
index 683c39cc42..2029ecedf7 100644
--- a/filters/crop/CropFilter.cpp
+++ b/filters/crop/CropFilter.cpp
@@ -34,6 +34,8 @@
 
 #include "CropFilter.hpp"
 
+#include <iomanip>
+
 #include <pdal/PointView.hpp>
 #include <pdal/StageFactory.hpp>
 #include <pdal/GDALUtils.hpp>
@@ -65,7 +67,6 @@ static void _GEOSErrorHandler(const char *fmt, ...)
     char buf[1024];
 
     vsnprintf(buf, sizeof(buf), fmt, args);
-    std::cerr << "GEOS Error: " << buf << std::endl;
 
     va_end(args);
 }
@@ -123,8 +124,12 @@ void CropFilter::processOptions(const Options& options)
 #ifdef PDAL_HAVE_GEOS
     if (m_polys.size())
     {
-        m_geosEnvironment = initGEOS_r(pdal::geos::_GEOSWarningHandler,
-            pdal::geos::_GEOSErrorHandler);
+        m_geoms.clear();
+        if (!m_geosEnvironment)
+        {
+            m_geosEnvironment = initGEOS_r(pdal::geos::_GEOSWarningHandler,
+                pdal::geos::_GEOSErrorHandler);
+        }
         for (std::string poly : m_polys)
         {
             GeomPkg g;
@@ -324,8 +329,10 @@ void CropFilter::done(PointTableRef /*table*/)
         GEOSPreparedGeom_destroy_r(m_geosEnvironment, g.m_prepGeom);
         GEOSGeom_destroy_r(m_geosEnvironment, g.m_geom);
     }
+    m_geoms.clear();
     if (m_geosEnvironment)
         finishGEOS_r(m_geosEnvironment);
+    m_geosEnvironment = 0;
 #endif
 }
 
diff --git a/plugins/attribute/CMakeLists.txt b/plugins/attribute/CMakeLists.txt
index 7bce37b71f..7c2096cd2f 100644
--- a/plugins/attribute/CMakeLists.txt
+++ b/plugins/attribute/CMakeLists.txt
@@ -16,6 +16,10 @@ if (GEOS_FOUND AND GDAL_FOUND)
     PDAL_ADD_PLUGIN(libname filter attribute
         FILES "${srcs}" "${incs}"
         LINK_WITH ${GEOS_LIBRARY} ${GDAL_LIBRARY})
+
+    if (WITH_TESTS)
+        PDAL_ADD_TEST(attrtest FILES test/AttributeFilterTest.cpp)
+    endif()
 else()
     message(STATUS "BUILD_PLUGIN_ATTRIBUTE disabled because GEOS and/or GDAL was not found")
 endif()
diff --git a/plugins/attribute/filters/AttributeFilter.cpp b/plugins/attribute/filters/AttributeFilter.cpp
index f98c06dd98..a5c994a2fa 100644
--- a/plugins/attribute/filters/AttributeFilter.cpp
+++ b/plugins/attribute/filters/AttributeFilter.cpp
@@ -35,6 +35,7 @@
 #include "AttributeFilter.hpp"
 
 #include <memory>
+#include <iomanip>
 
 #include <pdal/GlobalEnvironment.hpp>
 #include <pdal/GDALUtils.hpp>
@@ -99,13 +100,11 @@ Options AttributeFilter::getDefaultOptions()
 
     pdal::Option red("dimension", "Classification", "");
     pdal::Option b0("value","0", "");
-    pdal::Option geometry("geometry","POLYGON ((30 10, 40 40, 20 40, 10 20, 30 10))", "");
     pdal::Option query("query","", "");
     pdal::Option layer("layer","", "");
     pdal::Option datasource("datasource","", "");
     pdal::Options redO;
     redO.add(b0);
-    redO.add(geometry);
     redO.add(query);
     redO.add(layer);
     redO.add(datasource);
@@ -119,64 +118,66 @@ Options AttributeFilter::getDefaultOptions()
 
 void AttributeFilter::processOptions(const Options& options)
 {
-    std::vector<Option> dimensions = options.getOptions("dimension");
-    for (auto i = dimensions.begin(); i != dimensions.end(); ++i)
+    if (!options.hasOption("dimension"))
     {
-        std::string name = i->getValue<std::string>();
-        boost::optional<Options const&> dimensionOptions = i->getOptions();
-        if (!dimensionOptions)
-        {
-            std::ostringstream oss;
-            oss << "No options dimension given for dimension '" <<
-                name << "'";
-            throw pdal_error(oss.str());
-        }
-
-        AttributeInfo info;
-        info.datasource = dimensionOptions->getValueOrDefault<std::string>("datasource", "");
-
+        std::ostringstream oss;
+        oss << getName() << ": option --dimension must be specified.";
+        throw pdal_error(oss.str());
+    }
+    if (options.hasOption("value") && options.hasOption("datasource"))
+    {
+        std::ostringstream oss;
+        oss << getName() << ": options --value and --datasource mutually "
+            "exclusive.";
+        throw pdal_error(oss.str());
+    }
+    if (!options.hasOption("value") && !options.hasOption("datasource"))
+    {
+        std::ostringstream oss;
+        oss << getName() << ": Option --value or --datasource must be "
+            "specified.";
+        throw pdal_error(oss.str());
+    }
 
-        // If we have no datasource, then we're simply setting a value.
-        // If we have no value, throw an exception.
-        if (!info.datasource.size())
-        {
-            info.value = dimensionOptions->getValueOrThrow<std::string>("value");
-            info.isogr = false;
-        } else
-        {
-            info.column = dimensionOptions->getValueOrDefault<std::string>("column",""); // take first column
-            info.query = dimensionOptions->getValueOrDefault<std::string>("query","");
-            info.layer = dimensionOptions->getValueOrDefault<std::string>("layer",""); // take first layer
+    m_dimName = options.getValueOrDefault<std::string>("dimension");
+    m_value = options.getValueOrDefault<double>("value",
+        std::numeric_limits<double>::quiet_NaN());
+    m_datasource = options.getValueOrDefault<std::string>("datasource");
+    m_column = options.getValueOrDefault<std::string>("column");
+    m_query = options.getValueOrDefault<std::string>("query");
+    m_layer = options.getValueOrDefault<std::string>("layer");
+}
 
-        }
 
-        m_dimensions.insert(std::make_pair(name, info));
+void AttributeFilter::prepared(PointTableRef table)
+{
+    m_dim = table.layout()->findDim(m_dimName);
+    if (m_dim == Dimension::Id::Unknown)
+    {
+        std::ostringstream oss;
+        oss << getName() << ": Dimension '" << m_dimName << "' not found.";
+        throw pdal_error(oss.str());
     }
 }
 
+
 void AttributeFilter::ready(PointTableRef table)
 {
-    for (auto& dim_par : m_dimensions)
+    if (m_value != m_value)
     {
-        Dimension::Id::Enum t = table.layout()->findDim(dim_par.first);
-        dim_par.second.dim = t;
-
-        if (dim_par.second.isogr)
+        m_ds = OGRDSPtr(OGROpen(m_datasource.c_str(), 0, 0),
+            OGRDataSourceDeleter());
+        if (!m_ds)
         {
-
-            OGRDSPtr ds = OGRDSPtr(OGROpen(dim_par.second.datasource.c_str(), 0, 0), OGRDataSourceDeleter());
-            if (!ds)
-            {
-                std::ostringstream oss;
-                oss << "Unable to open data source '" << dim_par.second.datasource <<"'";
-                throw pdal_error(oss.str());
-            }
-            dim_par.second.ds = ds;
+            std::ostringstream oss;
+            oss << getName() << ": Unable to open data source '" <<
+                    m_datasource << "'";
+            throw pdal_error(oss.str());
         }
-
     }
 }
 
+
 BOX3D computeBounds(GEOSContextHandle_t ctx, GEOSGeometry const *geometry)
 {
     uint32_t numInputDims;
@@ -213,8 +214,7 @@ GEOSGeometry* createGEOSPoint(GEOSContextHandle_t ctx, double x, double y, doubl
     int ret(0);
 
     // precise filtering based on the geometry
-    GEOSCoordSequence* coords =
-        GEOSCoordSeq_create_r(ctx, 1, 3);
+    GEOSCoordSequence* coords = GEOSCoordSeq_create_r(ctx, 1, 3);
     if (!coords)
         throw pdal_error("unable to allocate coordinate sequence");
     ret = GEOSCoordSeq_setX_r(ctx, coords, 0, x);
@@ -233,47 +233,45 @@ GEOSGeometry* createGEOSPoint(GEOSContextHandle_t ctx, double x, double y, doubl
     return p;
 }
 
-void AttributeFilter::UpdateGEOSBuffer(PointView& view, AttributeInfo& info)
+void AttributeFilter::UpdateGEOSBuffer(PointView& view)
 {
     QuadIndex idx(view);
 
-    if (!info.lyr) // wake up the layer
+    if (m_layer.size())
+        m_lyr = OGR_DS_GetLayerByName(m_ds.get(), m_layer.c_str());
+    else if (m_query.size())
+        m_lyr = OGR_DS_ExecuteSQL(m_ds.get(), m_query.c_str(), 0, 0);
+    else
+        m_lyr = OGR_DS_GetLayer(m_ds.get(), 0);
+
+    if (!m_lyr)
     {
-        if (info.layer.size())
-            info.lyr = OGR_DS_GetLayerByName(info.ds.get(), info.layer.c_str());
-        else if (info.query.size())
-        {
-            info.lyr = OGR_DS_ExecuteSQL(info.ds.get(), info.query.c_str(), 0, 0);
-        }
-        else
-            info.lyr = OGR_DS_GetLayer(info.ds.get(), 0);
-        if (!info.lyr)
-        {
-            std::ostringstream oss;
-            oss << "Unable to select layer '" << info.layer << "'";
-            throw pdal_error(oss.str());
-        }
+        std::ostringstream oss;
+        oss << getName() << ": Unable to select layer '" << m_layer << "'";
+        throw pdal_error(oss.str());
     }
 
-    OGRFeaturePtr feature = OGRFeaturePtr(OGR_L_GetNextFeature(info.lyr), OGRFeatureDeleter());
+    OGRFeaturePtr feature = OGRFeaturePtr(OGR_L_GetNextFeature(m_lyr),
+        OGRFeatureDeleter());
 
     int field_index(1); // default to first column if nothing was set
-    if (info.column.size())
+    if (m_column.size())
     {
-
-        field_index = OGR_F_GetFieldIndex(feature.get(), info.column.c_str());
+        field_index = OGR_F_GetFieldIndex(feature.get(), m_column.c_str());
         if (field_index == -1)
         {
             std::ostringstream oss;
-            oss << "No column name '" << info.column << "' was found.";
+            oss << getName() << ": No column name '" << m_column <<
+                "' was found.";
             throw pdal_error(oss.str());
         }
     }
 
-    while(feature)
+    while (feature)
     {
         OGRGeometryH geom = OGR_F_GetGeometryRef(feature.get());
         OGRwkbGeometryType t = OGR_G_GetGeometryType(geom);
+        int32_t fieldVal = OGR_F_GetFieldAsInteger(feature.get(), field_index);
 
         if (!(t == wkbPolygon ||
             t == wkbMultiPolygon ||
@@ -281,27 +279,30 @@ void AttributeFilter::UpdateGEOSBuffer(PointView& view, AttributeInfo& info)
             t == wkbMultiPolygon25D))
         {
             std::ostringstream oss;
-            oss << "Geometry is not Polygon or MultiPolygon!";
+            oss << getName() << ": Geometry is not Polygon or MultiPolygon!";
             throw pdal::pdal_error(oss.str());
         }
 
         OGRGeometry* ogr_g = (OGRGeometry*) geom;
         GEOSGeometry* geos_g (0);
         if (!m_geosEnvironment)
-        {
+            m_geosEnvironment = ogr_g->createGEOSContext();
 
 #if (GDAL_VERSION_MINOR < 11) && (GDAL_VERSION_MAJOR == 1)
         geos_g = ogr_g->exportToGEOS();
 #else
-        m_geosEnvironment = ogr_g->createGEOSContext();
         geos_g = ogr_g->exportToGEOS(m_geosEnvironment);
-
 #endif
-        }
 
-        GEOSPreparedGeometry const* geos_pg = GEOSPrepare_r(m_geosEnvironment, geos_g);
+        GEOSPreparedGeometry const* geos_pg = GEOSPrepare_r(m_geosEnvironment,
+            geos_g);
         if (!geos_pg)
-            throw pdal_error("unable to prepare geometry for index-accelerated intersection");
+        {
+            std::ostringstream oss;
+            oss << getName() << ": unable to prepare geometry for "
+                "index-accelerated intersection";
+            throw pdal_error(oss.str());
+        }
 
         // Compute a total bounds for the geometry. Query the QuadTree to
         // find out the points that are inside the bbox. Then test each
@@ -317,40 +318,26 @@ void AttributeFilter::UpdateGEOSBuffer(PointView& view, AttributeInfo& info)
 
             GEOSGeometry* p = createGEOSPoint(m_geosEnvironment, x, y ,z);
 
-            if (static_cast<bool>(GEOSPreparedContains_r(m_geosEnvironment, geos_pg, p)))
+            if ((bool)(GEOSPreparedCovers_r(m_geosEnvironment, geos_pg, p)))
             {
                 // We're in the poly, write the attribute value
-                int32_t v = OGR_F_GetFieldAsInteger(feature.get(), field_index);
-                view.setField(info.dim, i, v);
-//                 log()->get(LogLevel::Debug) << "Setting value: " << v << std::endl;
+                view.setField(m_dim, i, fieldVal);
             }
-
             GEOSGeom_destroy_r(m_geosEnvironment, p);
-
         }
-
-        feature = OGRFeaturePtr(OGR_L_GetNextFeature(info.lyr), OGRFeatureDeleter());
+        feature = OGRFeaturePtr(OGR_L_GetNextFeature(m_lyr),
+            OGRFeatureDeleter());
     }
 }
 
 void AttributeFilter::filter(PointView& view)
 {
 
-    for (auto& dim_par : m_dimensions)
-    {
-        if (dim_par.second.isogr)
-        {
-            UpdateGEOSBuffer(view, dim_par.second);
-        }  else
-        {
-            for (PointId i = 0; i < view.size(); ++i)
-            {
-                double v = boost::lexical_cast<double>(dim_par.second.value);
-                view.setField(dim_par.second.dim, i, v);
-            }
-
-        }
-    }
+    if (m_value == m_value)
+        for (PointId i = 0; i < view.size(); ++i)
+            view.setField(m_dim, i, m_value);
+    else
+        UpdateGEOSBuffer(view);
 }
 
 } // namespace pdal
diff --git a/plugins/attribute/filters/AttributeFilter.hpp b/plugins/attribute/filters/AttributeFilter.hpp
index d9be09b17f..59d6e0271b 100644
--- a/plugins/attribute/filters/AttributeFilter.hpp
+++ b/plugins/attribute/filters/AttributeFilter.hpp
@@ -53,65 +53,15 @@ namespace gdal
     class ErrorHandler;
 }
 
-
 typedef std::shared_ptr<void> OGRDSPtr;
 typedef std::shared_ptr<void> OGRFeaturePtr;
 typedef std::shared_ptr<void> OGRGeometryPtr;
 
-class AttributeInfo
-{
-public:
-    AttributeInfo() : ds(0), lyr(0), isogr(true) {};
-
-    std::string connection;
-    std::string column;
-    std::string datasource;
-    OGRDSPtr ds;
-    OGRLayerH lyr;
-    std::string query;
-    std::string layer;
-    std::string value;
-    bool isogr;
-    Dimension::Id::Enum dim;
-    AttributeInfo(const AttributeInfo& other)
-        : connection(other.connection)
-        , column(other.column)
-        , datasource(other.datasource)
-        , ds(other.ds)
-        , lyr(other.lyr)
-        , query(other.query)
-        , layer(other.layer)
-        , value(other.value)
-        , isogr(other.isogr)
-        , dim(other.dim) {};
-    AttributeInfo& operator=(const AttributeInfo& other)
-    {
-        if (&other != this)
-        {
-            connection = other.connection;
-            column = other.column;
-            datasource = other.datasource;
-            ds = other.ds;
-            lyr = other.lyr;
-            query = other.query;
-            value = other.value;
-            layer = other.layer;
-            isogr = other.isogr;
-            dim = other.dim;
-        }
-        return *this;
-    }
-
-};
-
-
-typedef std::map< std::string, AttributeInfo> AttributeInfoMap;
-
-
 class PDAL_DLL AttributeFilter : public Filter
 {
 public:
-    AttributeFilter() : Filter(), m_geosEnvironment(0) {};
+    AttributeFilter() : Filter(), m_ds(0), m_lyr(0), m_geosEnvironment(0)
+    {}
 
     static void * create();
     static int32_t destroy(void *);
@@ -122,6 +72,7 @@ class PDAL_DLL AttributeFilter : public Filter
 private:
     virtual void initialize();
     virtual void processOptions(const Options&);
+    virtual void prepared(PointTableRef table);
     virtual void ready(PointTableRef table);
     virtual void filter(PointView& view);
 
@@ -130,10 +81,19 @@ class PDAL_DLL AttributeFilter : public Filter
 
     typedef std::shared_ptr<void> OGRDSPtr;
 
-    AttributeInfoMap m_dimensions;
+    OGRDSPtr m_ds;
+    OGRLayerH m_lyr;
+    std::string m_dimName;
+    double m_value;
+    std::string m_datasource;
+    std::string m_column;
+    std::string m_query;
+    std::string m_layer;
+    Dimension::Id::Enum m_dim;
+
     GEOSContextHandle_t m_geosEnvironment;
     std::unique_ptr<pdal::gdal::ErrorHandler> m_gdal_debug;
-    void UpdateGEOSBuffer(PointView& view, AttributeInfo& info);
+    void UpdateGEOSBuffer(PointView& view);
 
 };
 
diff --git a/plugins/attribute/test/AttributeFilterTest.cpp b/plugins/attribute/test/AttributeFilterTest.cpp
new file mode 100644
index 0000000000..8d74b1b73f
--- /dev/null
+++ b/plugins/attribute/test/AttributeFilterTest.cpp
@@ -0,0 +1,186 @@
+/******************************************************************************
+* Copyright (c) 2015, Hobu Inc. (info@hobu.co)
+*
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following
+* conditions are met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above copyright
+*       notice, this list of conditions and the following disclaimer in
+*       the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Hobu, Inc. nor the
+*       names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior
+*       written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+* OF SUCH DAMAGE.
+****************************************************************************/
+
+#include <pdal/pdal_test_main.hpp>
+
+#include <pdal/StageFactory.hpp>
+#include <pdal/util/FileUtils.hpp>
+
+#include "Support.hpp"
+
+using namespace pdal;
+
+TEST(AttributeFilterTest, value)
+{
+    Options ro;
+    ro.add("filename", Support::datapath("autzen/autzen-dd.las"));
+
+    StageFactory factory;
+    Stage& r = *(factory.createStage("readers.las", true));
+    r.setOptions(ro);
+
+    Options fo;
+    fo.add("dimension", "X");
+    fo.add("value", 27.5);
+
+    Stage& f = *(factory.createStage("filters.attribute", true));
+    f.setInput(r);
+    f.setOptions(fo);
+
+    std::string tempfile(Support::temppath("out.las"));
+
+    Options wo;
+    wo.add("filename", tempfile);
+    Stage& w = *(factory.createStage("writers.las", true));
+    w.setInput(f);
+    w.setOptions(wo);
+
+    FileUtils::deleteFile(tempfile);
+    PointTable t1;
+    w.prepare(t1); 
+    w.execute(t1);
+
+    Options testOptions;
+    testOptions.add("filename", tempfile);
+
+    Stage& test = *(factory.createStage("readers.las", true)); 
+    test.setOptions(testOptions);
+
+    PointTable t2;
+    test.prepare(t2);
+    PointViewSet s = test.execute(t2);
+    PointViewPtr v = *s.begin();
+    for (PointId i = 0; i < v->size(); ++i)
+        EXPECT_DOUBLE_EQ(v->getFieldAs<double>(Dimension::Id::X, i), 27.5);
+}
+
+TEST(AttributeFilterTest, datasource)
+{
+    Options ro;
+    ro.add("filename", Support::datapath("autzen/autzen-dd.las"));
+
+    StageFactory factory;
+    Stage& r = *(factory.createStage("readers.las", true));
+    r.setOptions(ro);
+
+    Options fo;
+    fo.add("dimension", "Classification");
+    fo.add("column", "cls");
+    fo.add("datasource", Support::datapath("autzen/attributes.shp"));
+
+    Stage& f = *(factory.createStage("filters.attribute", true));
+    f.setInput(r);
+    f.setOptions(fo);
+
+    std::string tempfile(Support::temppath("out.las"));
+
+    Options wo;
+    wo.add("filename", tempfile);
+    wo.add("forward", "all");
+    Stage& w = *(factory.createStage("writers.las", true));
+    w.setInput(f);
+    w.setOptions(wo);
+
+    FileUtils::deleteFile(tempfile);
+    PointTable t;
+    w.prepare(t); 
+    w.execute(t);
+
+// 
+//
+    Options testOptions;
+    testOptions.add("filename", tempfile);
+
+    Stage& test = *(factory.createStage("readers.las", true)); 
+    test.setOptions(testOptions);
+
+    Stage& c = *(factory.createStage("filters.crop", true));
+    c.setInput(test);
+
+    Options o1;
+    o1.add("polygon", "POLYGON ((-123.067019000727967 44.059524946819884,-123.066697831944637 44.059771500882199,-123.065494970755537 44.059838504937517,-123.064074882074451 44.059742872480356,-123.063707784110264 44.059184772926969,-123.06401206144227 44.05752667418929,-123.065925935478475 44.057786669839672,-123.065745673821624 44.058221493390228,-123.06633379431868 44.058264073197797,-123.066237450902648 44.058593303895073,-123.06633104847343 44.058966114097124,-123.06667192031054 44.059429072738524,-123.067019000727967 44.059524946819884))");
+
+    c.setOptions(o1);
+
+    PointTable t1;
+    c.prepare(t1);
+    PointViewSet s = c.execute(t1);
+    PointViewPtr v = *s.begin();
+    for (PointId i = 0; i < v->size(); ++i)
+        EXPECT_EQ(v->getFieldAs<int>(Dimension::Id::Classification, i), 2);
+
+    Options o2;
+    o2.add("polygon", "POLYGON ((-123.064404672110015 44.062248205780641,-123.063001791092177 44.062295757390288,-123.062938948566199 44.061866413306625,-123.063711529699802 44.061825083575727,-123.062903757506561 44.060798284876931,-123.0634590922878 44.06084959530147,-123.063939134831102 44.061205726019097,-123.064707560079256 44.061834553141757,-123.064404672110015 44.062248205780641))");
+    c.setOptions(o2);
+
+    PointTable t2;
+    c.prepare(t2);
+    s = c.execute(t2);
+    v = *s.begin();
+    for (PointId i = 0; i < v->size(); ++i)
+        EXPECT_EQ(v->getFieldAs<int>(Dimension::Id::Classification, i), 5);
+
+    Options o3;
+    o3.add("polygon", "POLYGON ((-123.071105494548775 44.059121603563895,-123.070160265697027 44.059007342229378,-123.070431650409773 44.058379004056327,-123.071225617617372 44.058576450660659,-123.071105494548775 44.059121603563895))");
+    c.setOptions(o3);
+
+    PointTable t3;
+    c.prepare(t3);
+    s = c.execute(t3);
+    v = *s.begin();
+    for (PointId i = 0; i < v->size(); ++i)
+        EXPECT_EQ(v->getFieldAs<int>(Dimension::Id::Classification, i), 6);
+
+    Options o4;
+    o4.add("polygon", "POLYGON ((-123.06887558672102 44.059227793751305,-123.068425255931515 44.059301773132752,-123.067936238335534 44.059248990941661,-123.06749590912527 44.059043544671049,-123.06710185170931 44.058629650191868,-123.067099413306224 44.058063335596437,-123.067333190514816 44.057587417330502,-123.067852567837207 44.057320435256116,-123.068290450314009 44.057214830538491,-123.068899280712444 44.057225021409202,-123.069338909397359 44.057414523826182,-123.069655618140771 44.057830157147713,-123.069799646794209 44.058090147755628,-123.069828689995248 44.058504298331584,-123.069657775977149 44.058899032362596,-123.06887558672102 44.059227793751305))");
+    c.setOptions(o4);
+
+    PointTable t4;
+    c.prepare(t4);
+    s = c.execute(t4);
+    v = *s.begin();
+    for (PointId i = 0; i < v->size(); ++i)
+        EXPECT_EQ(v->getFieldAs<int>(Dimension::Id::Classification, i), 6);
+
+    Options o5;
+    o5.add("polygon", "POLYGON ((-123.071871740947586 44.058426242457685,-123.070376025800414 44.058117017731242,-123.07060216253906 44.057465769662898,-123.072144836409578 44.057837746292243,-123.071871740947586 44.058426242457685))");
+    c.setOptions(o5);
+
+    PointTable t5;
+    c.prepare(t5);
+    s = c.execute(t5);
+    v = *s.begin();
+    for (PointId i = 0; i < v->size(); ++i)
+        EXPECT_EQ(v->getFieldAs<int>(Dimension::Id::Classification, i), 6);
+}