rename filters.expresion -> filters.mongo

doc/stages/filters.expression.rst → doc/stages/filters.mongoexpression.rst

@@ -1,6 +1,6 @@
-.. _filters.expression:
+.. _filters.mongoexpression:
 
-filters.expression
+filters.emongoxpression
 ==================
 
 .. contents::

doc/stages/filters.rst

@@ -195,6 +195,7 @@ the input. These filters will invalidate an existing KD-tree.
    filters.iqr
    filters.locate
    filters.mad
+   filters.mongoexpression
    filters.range
    filters.sample
    filters.tail
@@ -221,6 +222,9 @@ the input. These filters will invalidate an existing KD-tree.
     Cull points falling outside the computed Median Absolute Deviation for a
     given dimension.
 
+:ref:`filters.mongoexpression`
+    Cull points using MongoDB-style expression syntax.
+
 :ref:`filters.range`
     Pass only points given a dimension/range.
 

filters/ExpressionFilter.cpp → filters/MongoExpressionFilter.cpp

@@ -32,39 +32,39 @@
  * OF SUCH DAMAGE.
  ****************************************************************************/
 
-#include "ExpressionFilter.hpp"
+#include "MongoExpressionFilter.hpp"
 
-#include "private/expression/Expression.hpp"
+#include "private/mongoexpression/Expression.hpp"
 
 namespace pdal
 {
 
 static const StaticPluginInfo s_info
 {
-    "filters.expression",
+    "filters.mongo",
     "Pass only points that pass a logic filter.",
     "http://pdal.io/stages/filters.logic.html"
 };
 
-CREATE_STATIC_STAGE(ExpressionFilter, s_info);
+CREATE_STATIC_STAGE(MongoExpressionFilter, s_info);
 
-std::string ExpressionFilter::getName() const
+std::string MongoExpressionFilter::getName() const
 {
     return s_info.name;
 }
 
-ExpressionFilter::ExpressionFilter()
+MongoExpressionFilter::MongoExpressionFilter()
 {}
 
-ExpressionFilter::~ExpressionFilter()
+MongoExpressionFilter::~MongoExpressionFilter()
 {}
 
-void ExpressionFilter::addArgs(ProgramArgs& args)
+void MongoExpressionFilter::addArgs(ProgramArgs& args)
 {
     args.add("expression", "Logical query expression", m_json).setPositional();
 }
 
-void ExpressionFilter::prepared(PointTableRef table)
+void MongoExpressionFilter::prepared(PointTableRef table)
 {
     log()->get(LogLevel::Debug) << "Building expression from: " << m_json <<
         std::endl;
@@ -75,7 +75,7 @@ void ExpressionFilter::prepared(PointTableRef table)
         std::endl;
 }
 
-PointViewSet ExpressionFilter::run(PointViewPtr inView)
+PointViewSet MongoExpressionFilter::run(PointViewPtr inView)
 {
     PointViewSet views;
     PointViewPtr view(inView->makeNew());
@@ -93,7 +93,7 @@ PointViewSet ExpressionFilter::run(PointViewPtr inView)
     return views;
 }
 
-bool ExpressionFilter::processOne(PointRef& pr)
+bool MongoExpressionFilter::processOne(PointRef& pr)
 {
     return m_expression->check(pr);
 }

filters/ExpressionFilter.hpp → filters/MongoExpressionFilter.hpp

@@ -44,11 +44,11 @@ namespace pdal
 
 class Expression;
 
-class PDAL_DLL ExpressionFilter : public Filter, public Streamable
+class PDAL_DLL MongoExpressionFilter : public Filter, public Streamable
 {
 public:
-    ExpressionFilter();
-    ~ExpressionFilter();
+    MongoExpressionFilter();
+    ~MongoExpressionFilter();
 
     std::string getName() const override;
     virtual bool processOne(PointRef& point) override;

scripts/conda/osx.sh

@@ -2,36 +2,36 @@ export CONDA_EXE=/Users/hobu/miniconda3/bin/conda
 source /Users/hobu/miniconda3/bin/activate base
 
 
-$CONDA_EXE remove pdal
-$CONDA_EXE activate pdal
+# $CONDA_EXE remove pdal
+# $CONDA_EXE activate pdal
 source /Users/hobu/miniconda3/bin/activate pdal
-$CONDA_EXE config --add channels conda-forge
-$CONDA_EXE create --name pdal -y
-$CONDA_EXE install  -y laz-perf \
-                laszip \
-                libunwind \
-                geotiff \
-                jsoncpp \
-                sqlite \
-                libxml2 \
-                nitro \
-                curl \
-                gdal=2.3.2 \
-                postgresql \
-                hdf5 \
-                pcl \
-                cmake \
-                clang_osx-64 \
-                clangxx_osx-64 \
-                libspatialite \
-                eigen \
-                ninja \
-                libgdal \
-                geos \
-                zstd \
-                python=3.7 \
-                numpy
-#
+# $CONDA_EXE config --add channels conda-forge
+# $CONDA_EXE create --name pdal -y
+# $CONDA_EXE install  -y laz-perf \
+#                 laszip \
+#                 libunwind \
+#                 geotiff \
+#                 jsoncpp \
+#                 sqlite \
+#                 libxml2 \
+#                 nitro \
+#                 curl \
+#                 gdal=2.3.2 \
+#                 postgresql \
+#                 hdf5 \
+#                 pcl \
+#                 cmake \
+#                 clang_osx-64 \
+#                 clangxx_osx-64 \
+#                 libspatialite \
+#                 eigen \
+#                 ninja \
+#                 libgdal \
+#                 geos \
+#                 zstd \
+#                 python=3.7 \
+#                 numpy
+# #
 BUILDDIR=conda-build
 
 #export CC=/usr/bin/clang

test/unit/CMakeLists.txt

@@ -168,9 +168,9 @@ PDAL_ADD_TEST(pdal_filters_crop_test
 PDAL_ADD_TEST(pdal_filters_decimation_test FILES
     filters/DecimationFilterTest.cpp)
 PDAL_ADD_TEST(pdal_filters_divider_test FILES filters/DividerFilterTest.cpp)
-PDAL_ADD_TEST(pdal_filters_expression_test
+PDAL_ADD_TEST(pdal_filters_mongoexpression_test
     FILES
-        filters/ExpressionFilterTest.cpp
+        filters/MongoExpressionFilterTest.cpp
     LINK_WITH
         ${PDAL_JSONCPP_LIB_NAME}
 )

test/unit/filters/ExpressionFilterTest.cpp → test/unit/filters/MongoExpressionFilterTest.cpp

@@ -42,7 +42,7 @@
 
 #include <pdal/PointView.hpp>
 #include <pdal/StageFactory.hpp>
-#include <filters/ExpressionFilter.hpp>
+#include <filters/MongoExpressionFilter.hpp>
 
 using namespace pdal;
 
@@ -60,34 +60,34 @@ std::unique_ptr<FixedPointTable> makeTable()
     return table;
 }
 
-std::unique_ptr<ExpressionFilter> makeFilter(BasePointTable& table,
+std::unique_ptr<MongoExpressionFilter> makeFilter(BasePointTable& table,
         Json::Value expression)
 {
     Options o;
     o.add("expression", expression.toStyledString());
-    std::unique_ptr<ExpressionFilter> filter(new ExpressionFilter());
+    std::unique_ptr<MongoExpressionFilter> filter(new MongoExpressionFilter());
     filter->setOptions(o);
     filter->prepare(table);
     return filter;
 }
 
 } // unnamed namespace
 
-TEST(ExpressionFilterTest, createStage)
+TEST(MongoExpressionFilterTest, createStage)
 {
     StageFactory f;
-    Stage* filter(f.createStage("filters.expression"));
+    Stage* filter(f.createStage("filters.mongo"));
     EXPECT_TRUE(filter);
 }
 
-TEST(ExpressionFilterTest, noExpression)
+TEST(MongoExpressionFilterTest, noExpression)
 {
-    ExpressionFilter filter;
+    MongoExpressionFilter filter;
     PointTable table;
     EXPECT_THROW(filter.prepare(table), pdal_error);
 }
 
-TEST(ExpressionFilterTest, missingDimension)
+TEST(MongoExpressionFilterTest, missingDimension)
 {
     auto table(makeTable());
     PointRef pr(*table, 0);
@@ -107,7 +107,7 @@ TEST(ExpressionFilterTest, missingDimension)
     }
 }
 
-TEST(ExpressionFilterTest, invalidSingleComparisons)
+TEST(MongoExpressionFilterTest, invalidSingleComparisons)
 {
     auto table(makeTable());
     PointRef pr(*table, 0);
@@ -127,7 +127,7 @@ TEST(ExpressionFilterTest, invalidSingleComparisons)
     }
 }
 
-TEST(ExpressionFilterTest, singleComparisons)
+TEST(MongoExpressionFilterTest, singleComparisons)
 {
     auto table(makeTable());
     PointRef pr(*table, 0);
@@ -338,7 +338,7 @@ TEST(ExpressionFilterTest, singleComparisons)
     }
 }
 
-TEST(ExpressionFilterTest, inValidMultiComparisons)
+TEST(MongoExpressionFilterTest, inValidMultiComparisons)
 {
     auto table(makeTable());
     PointRef pr(*table, 0);
@@ -363,7 +363,7 @@ TEST(ExpressionFilterTest, inValidMultiComparisons)
     }
 }
 
-TEST(ExpressionFilterTest, multiComparisons)
+TEST(MongoExpressionFilterTest, multiComparisons)
 {
     auto table(makeTable());
     PointRef pr(*table, 0);
@@ -445,7 +445,7 @@ TEST(ExpressionFilterTest, multiComparisons)
     }
 }
 
-TEST(ExpressionFilterTest, invalidLogicalOperators)
+TEST(MongoExpressionFilterTest, invalidLogicalOperators)
 {
     auto table(makeTable());
     PointRef pr(*table, 0);
@@ -494,7 +494,7 @@ TEST(ExpressionFilterTest, invalidLogicalOperators)
     }
 }
 
-TEST(ExpressionFilterTest, logicalOperators)
+TEST(MongoExpressionFilterTest, logicalOperators)
 {
     auto table(makeTable());
     PointRef pr(*table, 0);