MAINT: add assignCrystVector to convert from array.

Re-enable _setInterpPoints function, but use shared
helper instead of spelling out numpy array copy.
Handle input arrays with non-unit strides.
Handle conversion from Python lists of floats.

Author: pavoljuhas

extensions/helpers.cpp

@@ -17,11 +17,20 @@
 *****************************************************************************/
 
 #include "helpers.hpp"
+#include <boost/python/stl_iterator.hpp>
+
 #include <iostream>
+#include <list>
 
-namespace bp = boost::python;
+#include <ObjCryst/CrystVector/CrystVector.h>
+
+// Use numpy here, but initialize it later in the extension module.
+#include "pyobjcryst_numpy_setup.hpp"
+#define NO_IMPORT_ARRAY
+#include <numpy/arrayobject.h>
 
-using namespace std;
+
+namespace bp = boost::python;
 
 void swapstdout(std::ostream& buf)
 {
@@ -30,3 +39,34 @@ void swapstdout(std::ostream& buf)
     std::cout.rdbuf(buf.rdbuf());
     buf.rdbuf(cout_strbuf);
 }
+
+
+void assignCrystVector(CrystVector<double>& cv, bp::object obj)
+{
+    // copy data directly if it is a numpy array of doubles
+    PyArrayObject* a = PyArray_Check(obj.ptr()) ?
+        reinterpret_cast<PyArrayObject*>(obj.ptr()) : NULL;
+    bool isdoublenumpyarray = a &&
+        (1 == PyArray_NDIM(a)) &&
+        (NPY_DOUBLE == PyArray_TYPE(a));
+    if (isdoublenumpyarray)
+    {
+        const double* src = static_cast<double*>(PyArray_DATA(a));
+        npy_intp stride = PyArray_STRIDE(a, 0) / PyArray_ITEMSIZE(a);
+        cv.resize(PyArray_SIZE(a));
+        double* dst = cv.data();
+        const double* last = dst + cv.size();
+        for (; dst != last; ++dst, src += stride)  *dst = *src;
+    }
+    // otherwise copy elementwise converting each element to a double
+    else
+    {
+        bp::stl_input_iterator<double> begin(obj), end;
+        // use intermediate list to preserve cv when conversion fails.
+        std::list<double> values(begin, end);
+        cv.resize(values.size());
+        std::list<double>::const_iterator vv = values.begin();
+        double* dst = cv.data();
+        for (; vv != values.end(); ++vv, ++dst)  *dst = *vv;
+    }
+}

extensions/helpers.hpp

@@ -109,4 +109,9 @@ bp::list setToPyList(std::set<T>& v)
 }
 
 
+// Extract CrystVector from a Python object
+template <class T> class CrystVector;
+
+void assignCrystVector(CrystVector<double>& cv, bp::object obj);
+
 #endif

extensions/powderpatternbackground_ext.cpp

@@ -21,35 +21,22 @@
 #include <boost/python/args.hpp>
 #include <boost/python/copy_const_reference.hpp>
 
-#include <numpy/noprefix.h>
-#include <numpy/arrayobject.h>
-
 #include <ObjCryst/ObjCryst/PowderPattern.h>
 
+#include "helpers.hpp"
+
 namespace bp = boost::python;
 using namespace ObjCryst;
 
 namespace {
 
 void _SetInterpPoints(PowderPatternBackground& b,
-        PyObject* tth, PyObject* backgd)
+        bp::object tth, bp::object backgd)
 {
-    // FIXME -- adjust for NumPy C-API 1.7
-
-    // // cout << "_SetInterpPoints:" << tth << ", " << backgd << endl;
-    // // cout << "dimensions = " << PyArray_NDIM(tth) << endl;
-    // const unsigned long nb = *(PyArray_DIMS((PyObject*)tth));
-    // // cout << "nbPoints = " << nb << endl;
-    // CrystVector_REAL tth2(nb), backgd2(nb);
-    // // FIXME -- reuse some conversion function here
-    // //:TODO: We assume the arrays are contiguous & double (float64) !
-    // double* p = (double*) (PyArray_DATA(tth));
-    // double* p2 = (double*) (tth2.data());
-    // for (unsigned long i = 0; i < nb; i++) *p2++ = *p++;
-    // p = (double*) (PyArray_DATA(backgd));
-    // p2 = (double*) (backgd2.data());
-    // for (unsigned long i = 0; i < nb; i++) *p2++ = *p++;
-    // b.SetInterpPoints(tth2, backgd2);
+    CrystVector_REAL cvtth, cvbackg;
+    assignCrystVector(cvtth, tth);
+    assignCrystVector(cvbackg, backgd);
+    b.SetInterpPoints(cvtth, cvbackg);
 }
 
 }   // namespace