Drop PyPipelineExecutor class, convert its methods to plain functions

Author: gsakkis

pdal/PyPipeline.cpp

@@ -32,6 +32,7 @@
 * OF SUCH DAMAGE.
 ****************************************************************************/
 
+#include "PyArray.hpp"
 #include "PyPipeline.hpp"
 
 #ifndef _WIN32
@@ -43,25 +44,33 @@
 #include <pdal/Stage.hpp>
 #include <pdal/pdal_features.hpp>
 
-#include "PyArray.hpp"
-
 namespace pdal
 {
 namespace python
 {
 
-// Create a pipeline for writing data to PDAL
-PyPipelineExecutor::PyPipelineExecutor(std::string const& json,
-    std::vector<Array*> arrays) : PipelineExecutor(json)
+
+void readPipeline(PipelineExecutor* executor, std::string json)
 {
+    std::stringstream strm(json);
+    executor->getManager().readPipeline(strm);
+}
+
+
+void addArrayReaders(PipelineExecutor* executor, std::vector<Array*> arrays)
+{
+    // Make the symbols in pdal_base global so that they're accessible
+    // to PDAL plugins.  Python dlopen's this extension with RTLD_LOCAL,
+    // which means that without this, symbols in libpdal_base aren't available
+    // for resolution of symbols on future runtime linking.  This is an issue
+    // on Alpine and other Linux variants that don't use UNIQUE symbols
+    // for C++ template statics only.  Without this, you end up with multiple
+    // copies of template statics.
 #ifndef _WIN32
-    // See comment in alternate constructor below.
     ::dlopen("libpdal_base.so", RTLD_NOLOAD | RTLD_GLOBAL);
 #endif
 
-    PipelineManager& manager = getManager();
-    std::stringstream strm(json);
-    manager.readPipeline(strm);
+    PipelineManager& manager = executor->getManager();
     std::vector<Stage *> roots = manager.roots();
     if (roots.size() != 1)
         throw pdal_error("Filter pipeline must contain a single root stage.");
@@ -100,20 +109,6 @@ PyPipelineExecutor::PyPipelineExecutor(std::string const& json,
     manager.validateStageOptions();
 }
 
-// Create a pipeline for reading data from PDAL
-PyPipelineExecutor::PyPipelineExecutor(std::string const& json) : PipelineExecutor(json)
-{
-    // Make the symbols in pdal_base global so that they're accessible
-    // to PDAL plugins.  Python dlopen's this extension with RTLD_LOCAL,
-    // which means that without this, symbols in libpdal_base aren't available
-    // for resolution of symbols on future runtime linking.  This is an issue
-    // on Alpine and other Linux variants that don't use UNIQUE symbols
-    // for C++ template statics only.  Without this, you end up with multiple
-    // copies of template statics.
-#ifndef _WIN32
-    ::dlopen("libpdal_base.so", RTLD_NOLOAD | RTLD_GLOBAL);
-#endif
-}
 
 inline PyObject* buildNumpyDescription(PointViewPtr view)
 {
@@ -182,10 +177,10 @@ PyArrayObject* viewToNumpyArray(PointViewPtr view)
     return array;
 }
 
-std::vector<PyArrayObject*> PyPipelineExecutor::getArrays() const
+std::vector<PyArrayObject*> getArrays(const PipelineExecutor* executor)
 {
     std::vector<PyArrayObject*> output;
-    for (auto view: getManagerConst().views())
+    for (auto view: executor->getManagerConst().views())
         output.push_back(viewToNumpyArray(view));
     return output;
 }
@@ -243,10 +238,10 @@ PyArrayObject* meshToNumpyArray(const TriangularMesh* mesh)
 }
 
 
-std::vector<PyArrayObject*> PyPipelineExecutor::getMeshes() const
+std::vector<PyArrayObject*> getMeshes(const PipelineExecutor* executor)
 {
     std::vector<PyArrayObject*> output;
-    for (auto view: getManagerConst().views())
+    for (auto view: executor->getManagerConst().views())
         output.push_back(meshToNumpyArray(view->mesh()));
     return output;
 }

pdal/PyPipeline.hpp

@@ -45,14 +45,12 @@ namespace python
 
 class Array;
 
-class PyPipelineExecutor : public PipelineExecutor
-{
-public:
-    PyPipelineExecutor(std::string const& json);
-    PyPipelineExecutor(std::string const& json, std::vector<Array*> arrays);
-    std::vector<PyArrayObject*> getArrays() const;
-    std::vector<PyArrayObject*> getMeshes() const;
-};
+void readPipeline(PipelineExecutor* executor, std::string json);
+void addArrayReaders(PipelineExecutor* executor, std::vector<Array*> arrays);
+PyArrayObject* viewToNumpyArray(PointViewPtr view);
+PyArrayObject* meshToNumpyArray(const TriangularMesh* mesh);
+std::vector<PyArrayObject*> getArrays(const PipelineExecutor* executor);
+std::vector<PyArrayObject*> getMeshes(const PipelineExecutor* executor);
 
 } // namespace python
 } // namespace pdal

pdal/libpdalpython.pyx

@@ -2,12 +2,13 @@
 # cython: c_string_type=unicode, c_string_encoding=utf8
 
 import json
+from types import SimpleNamespace
+
 from cpython.ref cimport Py_DECREF
 from libcpp.vector cimport vector
 from libcpp.string cimport string
 from libc.stdint cimport int64_t
 from libcpp cimport bool
-from types import SimpleNamespace
 
 import numpy as np
 cimport numpy as np
@@ -60,34 +61,38 @@ cdef extern from "PyArray.hpp" namespace "pdal::python":
         Array(np.ndarray) except +
 
 
-cdef extern from "PyPipeline.hpp" namespace "pdal::python":
-    cdef cppclass PyPipelineExecutor:
-        PyPipelineExecutor(const char*) except +
-        PyPipelineExecutor(const char*, vector[Array*]&) except +
+cdef extern from "pdal/PipelineExecutor.hpp" namespace "pdal":
+    cdef cppclass PipelineExecutor:
+        PipelineExecutor(const char*) except +
         bool executed() except +
         int64_t execute() except +
         bool validate() except +
         string getPipeline() except +
         string getMetadata() except +
         string getSchema() except +
         string getLog() except +
-        vector[np.PyArrayObject*] getArrays() except +
-        vector[np.PyArrayObject*] getMeshes() except +
         int getLogLevel()
         void setLogLevel(int)
 
 
+cdef extern from "PyPipeline.hpp" namespace "pdal::python":
+    void readPipeline(PipelineExecutor*, string) except +
+    void addArrayReaders(PipelineExecutor*, vector[Array *]) except +
+    vector[np.PyArrayObject*] getArrays(const PipelineExecutor* executor) except +
+    vector[np.PyArrayObject*] getMeshes(const PipelineExecutor* executor) except +
+
+
 cdef class Pipeline:
-    cdef PyPipelineExecutor* _executor
+    cdef PipelineExecutor* _executor
     cdef vector[Array *] _arrays;
 
     def __cinit__(self, unicode json, list arrays=None):
+        self._executor = new PipelineExecutor(json.encode('UTF-8'))
+        readPipeline(self._executor, json.encode('UTF-8'))
         if arrays is not None:
             for array in arrays:
                 self._arrays.push_back(new Array(array))
-            self._executor = new PyPipelineExecutor(json.encode('UTF-8'), self._arrays)
-        else:
-            self._executor = new PyPipelineExecutor(json.encode('UTF-8'))
+        addArrayReaders(self._executor, self._arrays)
 
     def __dealloc__(self):
         for array in self._arrays:
@@ -120,13 +125,13 @@ cdef class Pipeline:
         def __get__(self):
             if not self._executor.executed():
                 raise RuntimeError("call execute() before fetching arrays")
-            return self._vector_to_list(self._executor.getArrays())
+            return self._vector_to_list(getArrays(self._executor))
 
     property meshes:
         def __get__(self):
             if not self._executor.executed():
                 raise RuntimeError("call execute() before fetching the mesh")
-            return self._vector_to_list(self._executor.getMeshes())
+            return self._vector_to_list(getMeshes(self._executor))
 
     def execute(self):
         return self._executor.execute()