Added function to read in a numpy array as PixelData

Author: joeljonsson

src/wrapper/pythonBind.cpp

@@ -3,6 +3,8 @@
 //
 
 #include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
 
 #include "ConfigAPR.h"
 #include "data_structures/APR/APR.hpp"
@@ -19,21 +21,60 @@ namespace py = pybind11;
 // -------- Utility classes to be wrapped in python ----------------------------
 template <typename T>
 class AprToImg {
+    PixelData <T> originalImage;
+
+    APR <T> apr;
+
     PixelData <T> reconstructedImage;
 
 public:
     AprToImg () {}
     void read(const std::string &aAprFileName) {
-        APR <T> apr;
         apr.read_apr(aAprFileName);
-        ReconPatch r;
-        APRReconstruction().interp_image_patch(apr, reconstructedImage, apr.particles_intensities, r);
+        //ReconPatch r;
+        //APRReconstruction().interp_image_patch(apr, reconstructedImage, apr.particles_intensities, r);
+    }
+
+    T* pc_recon() {
+        APRReconstruction().interp_img(apr, reconstructedImage, apr.particles_intensities);
+
+        return reconstructedImage.mesh.get();
+    }
+
+    bool readArr(py::handle src, bool convert) {
+
+        /* Some sanity checks ... */
+        if (!convert && !py::array_t<T>::check_(src)) {
+            std::cout << "failed type check" << std::endl;
+            return false;
+        }
+
+        auto buf = py::array_t<T, py::array::c_style | py::array::forcecast>::ensure(src);
+        if (!buf) {
+            std::cout << "could not read buffer" << std::endl;
+            return false;
+        }
+
+        auto dims = buf.ndim();
+        if (dims != 3) {
+            std::cout << "failed dimension check" << std::endl;
+            return false;
+        }
+
+        /* read in python array to originalImage */
+        originalImage.init(buf.shape()[0], buf.shape()[1], buf.shape()[2]);
+
+        for(int i=0; i<originalImage.mesh.size(); ++i) {
+            originalImage.mesh[i] = buf.data()[i] + 1;
+        }
+
+        return true;
     }
 
-    T *data() {return reconstructedImage.mesh.get();}
-    int height() const {return reconstructedImage.x_num;}
-    int width() const {return reconstructedImage.y_num;}
-    int depth() const {return reconstructedImage.z_num;}
+    T *data() {return originalImage.mesh.get();}
+    int height() const {return originalImage.x_num;}
+    int width() const {return originalImage.y_num;}
+    int depth() const {return originalImage.z_num;}
 };
 
 // -------- Templated wrapper -------------------------------------------------
@@ -44,9 +85,11 @@ void AddAprToImg(pybind11::module &m, const std::string &aTypeString) {
     py::class_<AprType>(m, typeStr.c_str(), py::buffer_protocol())
             .def(py::init())
             .def("read", &AprType::read, "Method to read HDF5 APR files")
+            .def("reconstruct", &AprType::pc_recon, "returns an image reconstructed from the APR")
             .def("width", &AprType::width, "Returns number of columns (x)")
             .def("height", &AprType::height, "Returns number of rows (y)")
             .def("depth", &AprType::depth, "Returns depth (z)")
+            .def("readArr", &AprType::readArr, "reads in a python array")
             .def_buffer([](AprType &a) -> py::buffer_info{
                 return py::buffer_info(
                         a.data(),

test/pythonTest.py

@@ -10,6 +10,20 @@
 import pyApr
 import numpy as np
 apr=pyApr.AprShort()
+
 apr.read(myPath + '/files/Apr/sphere_120/sphere_apr.h5')
+img=np.array(apr.reconstruct(), copy = False)
+print(img.shape)
+
+img=np.arange(1000, dtype = np.uint16).reshape(10,10,10)
+
+if(apr.readArr(img, False)):
+    print('array successfully read into c++')
+else:
+    print('Error: array could not be read into c++')
+
+
 img=np.array(apr, copy = False)
-assert img.shape == (120, 120, 120)
+print(img.shape)
+# plot a 2D slice of the image
+