pybind11 working for RectilinearGrid

CMake/SuperBuild.cmake

 
 endif()
 
+if (LEMMA_PYTHON3_BINDINGS)
+    if (pybind11_FOUND)
+        message( STATUS "pybind11 was found" )
+    else()
+        message( STATUS "pybind11 was NOT found, please build or remove LEMMA_PYTHON3_BINDINGS" )
+	    ExternalProject_Add(pybind11
+		    GIT_REPOSITORY "https://github.com/pybind/pybind11.git"
+		    GIT_TAG "master"
+		    UPDATE_COMMAND ""
+		    PATCH_COMMAND ""
+    	    PREFIX ${CMAKE_CURRENT_BINARY_DIR}/external/pybind11
+            CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=${CMAKE_INSTALL_PREFIX} 
+                       -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}
+                       -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} 
+                       -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
+                       -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} 
+                       -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} 
+		    #CONFIGURE_COMMAND ""
+		    #BUILD_COMMAND     ""
+		    #INSTALL_COMMAND   ""
+	    )
+    endif()
+endif()
 
 if (LEMMA_ENABLE_TESTING)
     if (CXXTEST_FOUND)

CMakeLists.txt

 
     find_package (yaml-cpp 0.6         PATHS ${CMAKE_INSTALL_PREFIX}  NO_DEFAULT_PATH) # Serialisation of classes 
     find_package (Eigen3   3.3         PATHS ${CMAKE_INSTALL_PREFIX}  NO_DEFAULT_PATH) # Matrix/Vector & Math
+
+    if (LEMMA_PYTHON3_BINDINGS)
+        find_package(pybind11 PATHS ${CMAKE_INSTALL_PREFIX} NO_DEFAULT_PATH)           # Python 3 bindings
+    endif()
+
 #${CMAKE_INSTALL_PREFIX}  NO_DEFAULT_PATH 
     if (LEMMA_VTK8_SUPPORT)                                                            # Visualisation 
         find_package (VTK  8.2.0      
 ## Optional Dependencies
 if ( NOT Eigen3_FOUND OR 
      NOT yaml-cpp_FOUND OR 
+     (LEMMA_PYTHON3_BINDINGS AND NOT pybind11_FOUND) OR 
      (LEMMA_VTK8_SUPPORT AND NOT VTK_FOUND) OR
      (LEMMA_ENABLE_TESTING AND NOT CxxTest_FOUND) )
     message ( STATUS "Missing hard dependencies have been found, these will be downloaded any compiled." )
 endif()
 
 if (LEMMA_PYTHON3_BINDINGS)
-
     find_package(PythonLibs 3.0 REQUIRED)
-    find_package(Boost 1.64.0   REQUIRED COMPONENTS system python3 numpy3)
-
+    find_package(pybind11 REQUIRED)
+    #    find_package(Boost 1.64.0   REQUIRED COMPONENTS system python3 numpy3)
     # Is this OK for portability of non-python libraries
     include_directories(${PYTHON_INCLUDE_DIRS})
-    include_directories(${Boost_INCLUDE_DIRS})
-
+#    include_directories(${Boost_INCLUDE_DIRS})
 endif()
 
 ####################

Modules/LemmaCore/CMakeLists.txt

 # Python Bindings
 if (LEMMA_PYTHON3_BINDINGS)
 	add_subdirectory(python)
+	#pybind11_add_module(Lemma pyLemmaCore.cpp)
 endif()
 
 # Install

Modules/LemmaCore/include/RectilinearGrid.h

             virtual YAML::Node Serialize() const;
 
             /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            virtual std::string Print() const;
+
+            /**
              *  Factory method for generating concrete class.
              *  @return a std::shared_ptr of type RectilinearGrid
              */
             /** Returns a spacing
              *  @return dx[ix]
              */
-            Real GetDx(const int& ix);
+            Real GetDx1(const int& ix);
 
             /** Returns Spacing Vector
              *  @return dy
             /** Returns a spacing
              *  @return dy[iy]
              */
-            Real GetDy(const int& iy);
+            Real GetDy1(const int& iy);
 
             /** Returns Spacing Vector
              *  @return dz
             /** Returns Spacing Vector
              *  @return dz[iz]
              */
-            Real GetDz(const int& iz);
+            Real GetDz1(const int& iz);
 
             // ====================  INQUIRY       =======================
 
 #endif   // ----- #ifndef RECTILINEARGRID_INC  -----
 
 /* vim: set tabstop=4 expandtab: */
-/* vim: set filetype=cpp syntax=cpp.doxygen: */
+/* vim: set filetype=cpp syntax=cpp.doxygen */

Modules/LemmaCore/python/CMakeLists.txt

 # include directories
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/python)
+#include_directories(${CMAKE_CURRENT_SOURCE_DIR}/python)
 
 # create the lib
-add_library(pyLemmaCore SHARED ${CMAKE_CURRENT_SOURCE_DIR}/pyLemmaCore.cpp)
+#add_subdirectory( ${CMAKE_CURRENT_SOURCE_DIR} )
+#pybind11_add_module(pyLemmaCore pyLemmaCore.cpp)
+
+add_library(pyLemmaCore MODULE pyLemmaCore.cpp)
+target_link_libraries(pyLemmaCore PRIVATE pybind11::module lemmacore )
+set_target_properties(pyLemmaCore PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
+                                         SUFFIX "${PYTHON_MODULE_EXTENSION}")
+
+#target_include_directories( lemmacore PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../include" )
+
+#add_library(pyLemmaCore SHARED ${CMAKE_CURRENT_SOURCE_DIR}/pyLemmaCore.cpp)
 
 # link
-target_link_libraries(pyLemmaCore ${Boost_LIBRARIES} lemmacore)
+#target_link_libraries(pyLemmaCore lemmacore)
 
 # Copy the __init__.py file
-configure_file(__init__.py ${CMAKE_CURRENT_BINARY_DIR}/__init__.py COPYONLY)
+#configure_file(__init__.py ${CMAKE_CURRENT_BINARY_DIR}/__init__.py COPYONLY)
 
 # Suppress prefix "lib" because Python does not allow this prefix
-set_target_properties(pyLemmaCore PROPERTIES PREFIX "")
+#set_target_properties(pyLemmaCore PROPERTIES PREFIX "")
 
 #install(TARGETS pyLemmaCore __init__.py DESTINATION "${PYTHON_INSTALL_PATH}")

Modules/LemmaCore/python/pyLemmaCore.cpp

  * @copyright Copyright (c) 2019, Lemma Software, LLC
  */
 
+#include <pybind11/pybind11.h>
+#include <pybind11/iostream.h>
+#include <pybind11/eigen.h>
 #include "LemmaCore"
-#include <string>
 
-#include <boost/python.hpp>
-#include <boost/python/numpy.hpp>
-// Include the headers of MyLib
+namespace py = pybind11;
 
-//using namespace boost::python;
+PYBIND11_MODULE(pyLemmaCore, m) {
 
-namespace bp = boost::python;
-namespace np = boost::python::numpy;
+    py::add_ostream_redirect(m, "ostream_redirect");
 
+    m.doc() = "Python binding of LemmaCore, additional details can be found at https://lemmasoftware.org";
+
+    py::class_<Lemma::RectilinearGrid, std::shared_ptr<Lemma::RectilinearGrid> >(m, "RectilinearGrid")
+
+        // lifecycle
+        .def(py::init(&Lemma::RectilinearGrid::NewSP))
+
+        // print
+        .def("__repr__", &Lemma::RectilinearGrid::Print)
+        .def("Serialize", &Lemma::RectilinearGrid::Print)
+
+        // accessors
+        .def("GetName", &Lemma::RectilinearGrid::GetName, "Returns the name of the class")
+        .def("GetNx", &Lemma::RectilinearGrid::GetNx, "Returns the number of cells in the x direction")
+        .def("GetNy", &Lemma::RectilinearGrid::GetNy, "Returns the number of cells in the y direction")
+        .def("GetNz", &Lemma::RectilinearGrid::GetNz, "Returns the number of cells in the z direction")
+        .def("GetOx", &Lemma::RectilinearGrid::GetOx, "Returns the grid origin offset in the x direction")
+        .def("GetOy", &Lemma::RectilinearGrid::GetOy, "Returns the grid origin offset in the y direction")
+        .def("GetOz", &Lemma::RectilinearGrid::GetOz, "Returns the grid origin offset in the z direction")
+        .def("GetDx", &Lemma::RectilinearGrid::GetDx, "Returns the grid spacing in the x direction")
+        .def("GetDy", &Lemma::RectilinearGrid::GetDy, "Returns the grid spacing in the y direction")
+        .def("GetDz", &Lemma::RectilinearGrid::GetDz, "Returns the grid spacing in the z direction")
+
+        .def("SetDimensions", &Lemma::RectilinearGrid::SetDimensions, "Sets the number of cells in x, y, and z")
+        .def("SetOffset", &Lemma::RectilinearGrid::SetOffset, "Sets the origin offset in x, y, and z")
+        .def("SetSpacing", &Lemma::RectilinearGrid::SetSpacing, "Sets the grid spacing in x, y, and z");
+}
+
+
+/*
 BOOST_PYTHON_MODULE(pyLemmaCore)
 {
     Py_Initialize();
         //.def("DeSerialize", &Lemma::RectilinearGrid::DeSerialize)
 
         // Accessors
-        .def("GetName", &Lemma::RectilinearGrid::GetName)
-        .def("GetNx", &Lemma::RectilinearGrid::GetNx)
-        .def("GetNy", &Lemma::RectilinearGrid::GetNy)
-        .def("GetNz", &Lemma::RectilinearGrid::GetNz)
-        .def("GetOx", &Lemma::RectilinearGrid::GetOx)
-        .def("GetOy", &Lemma::RectilinearGrid::GetOy)
-        .def("GetOz", &Lemma::RectilinearGrid::GetOz)
-        //.def("GetDx", &Lemma::RectilinearGrid::GetDx)
-        //.def("GetDy", &Lemma::RectilinearGrid::GetDy)
-        //.def("GetDz", &Lemma::RectilinearGrid::GetDz)
-
-        .def("SetDimensions", &Lemma::RectilinearGrid::SetDimensions)
-        .def("SetOffset", &Lemma::RectilinearGrid::SetOffset)
-        .def("SetSpacing", &Lemma::RectilinearGrid::SetSpacing)
+
+
 
     ;
 
 }
+*/

Modules/LemmaCore/src/RectilinearGrid.cpp

         return node;
     }
 
+    std::string RectilinearGrid::Print() const {
+        YAML::Emitter out;
+        out << this->Serialize();
+        return out.c_str();
+    }
+
 
     //--------------------------------------------------------------------------------------
     //       Class:  RectilinearGrid
     //       Class:  RectilinearGrid
     //      Method:  GetDx
     //--------------------------------------------------------------------------------------
-    Real RectilinearGrid::GetDx ( const int& ix  ) {
+    Real RectilinearGrid::GetDx1 ( const int& ix  ) {
         return dx[ix];
     }		// -----  end of method RectilinearGrid::GetDx  -----
 
     //       Class:  RectilinearGrid
     //      Method:  GetDy
     //--------------------------------------------------------------------------------------
-    Real RectilinearGrid::GetDy ( const int& iy  ) {
+    Real RectilinearGrid::GetDy1 ( const int& iy  ) {
         return dy[iy];
     }		// -----  end of method RectilinearGrid::GetDy  -----
 
     //       Class:  RectilinearGrid
     //      Method:  GetDz
     //--------------------------------------------------------------------------------------
-    Real RectilinearGrid::GetDz ( const int& iz  ) {
+    Real RectilinearGrid::GetDz1 ( const int& iz  ) {
         return dz[iz];
     }		// -----  end of method RectilinearGrid::GetDz  -----
 

Modules/LemmaCore/src/RectilinearGridVTKExporter.cpp

 
     // Set Coordinate>s
     vtkDoubleArray *xCoords = vtkDoubleArray::New();
-    xCoords->InsertNextValue(Grid->GetOx()-Grid->GetDx(0)/2.);
-    double xm1 = Grid->GetOx() - Grid->GetDx(0)/2.;
+    xCoords->InsertNextValue(Grid->GetOx()-Grid->GetDx1(0)/2.);
+    double xm1 = Grid->GetOx() - Grid->GetDx1(0)/2.;
     for (int ix=0; ix<Grid->GetNx(); ix++) {
-        xCoords->InsertNextValue(xm1 + Grid->GetDx(ix));
-        xm1 += Grid->GetDx(ix);
+        xCoords->InsertNextValue(xm1 + Grid->GetDx1(ix));
+        xm1 += Grid->GetDx1(ix);
     }
 
     vtkDoubleArray *yCoords = vtkDoubleArray::New();
-    yCoords->InsertNextValue(Grid->GetOy()-Grid->GetDy(0)/2.);
-    double ym1 = Grid->GetOy()-Grid->GetDy(0)/2.;
+    yCoords->InsertNextValue(Grid->GetOy()-Grid->GetDy1(0)/2.);
+    double ym1 = Grid->GetOy()-Grid->GetDy1(0)/2.;
     for (int iy=0; iy<Grid->GetNy(); iy++) {
-        yCoords->InsertNextValue(ym1 + Grid->GetDy(iy));
-        ym1 += Grid->GetDy(iy);
+        yCoords->InsertNextValue(ym1 + Grid->GetDy1(iy));
+        ym1 += Grid->GetDy1(iy);
     }
 
     vtkDoubleArray *zCoords = vtkDoubleArray::New();
-    zCoords->InsertNextValue(Grid->GetOz()-Grid->GetDz(0)/2.);
-    double zm1 = Grid->GetOz()-Grid->GetDz(0)/2.;
+    zCoords->InsertNextValue(Grid->GetOz()-Grid->GetDz1(0)/2.);
+    double zm1 = Grid->GetOz()-Grid->GetDz1(0)/2.;
     for (int iz=0; iz<Grid->GetNz(); iz++) {
-        zCoords->InsertNextValue(zm1 + Grid->GetDz(iz));
-        zm1 += Grid->GetDz(iz);
+        zCoords->InsertNextValue(zm1 + Grid->GetDz1(iz));
+        zm1 += Grid->GetDz1(iz);
     }
 
     VTKGrid = vtkSmartPointer<vtkRectilinearGrid>::New();