NDArrayToVector.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include "MantidPythonInterface/core/Converters/NDArrayToVector.h"
#include "MantidPythonInterface/core/Converters/NDArrayTypeIndex.h"
#include "MantidPythonInterface/core/Converters/NumpyFunctions.h"
#include "MantidPythonInterface/core/DllConfig.h"
 
#include <boost/python/extract.hpp>
#include <boost/python/stl_iterator.hpp>
#include <boost/python/str.hpp>
 
#define PY_ARRAY_UNIQUE_SYMBOL CORE_ARRAY_API
#define NO_IMPORT_ARRAY
#include <numpy/arrayobject.h>
 
using boost::python::extract;
using boost::python::handle;
using boost::python::object;
using boost::python::str;
 
namespace Mantid::PythonInterface {
namespace Converters {
 
#define DECLARE_EXTERN(HeldType)                                                                                       \
  extern template int NDArrayTypeIndex<HeldType>::typenum;                                                             \
  extern template char NDArrayTypeIndex<HeldType>::typecode;
 
DECLARE_EXTERN(bool)
DECLARE_EXTERN(int)
DECLARE_EXTERN(long)
DECLARE_EXTERN(long long)
DECLARE_EXTERN(unsigned int)
DECLARE_EXTERN(unsigned long)
DECLARE_EXTERN(unsigned long long)
DECLARE_EXTERN(double)
DECLARE_EXTERN(float)
 
} // namespace Converters
 
namespace {
 
//-------------------------------------------------------------------------
// Template helpers
//-------------------------------------------------------------------------
template <typename DestElementType> struct CopyToImpl {
  void operator()(typename Converters::NDArrayToVector<DestElementType>::TypedVectorIterator first,
                  PyArrayObject *arr) {
    // Use the iterator API to iterate through the array
    // and assign each value to the corresponding vector
    object iter(handle<>(Converters::Impl::func_PyArray_IterNew(arr)));
    do {
      void *data = PyArray_ITER_DATA(iter.ptr());
      *first++ = *static_cast<DestElementType *>(data);
      PyArray_ITER_NEXT(iter.ptr());
    } while (PyArray_ITER_NOTDONE(iter.ptr()));
  }
};
 
template <> struct CopyToImpl<std::string> {
  void operator()(typename std::vector<std::string>::iterator first, PyArrayObject *arr) {
    object flattened(handle<>(PyArray_Ravel(arr, NPY_CORDER)));
    const Py_ssize_t nelements = PyArray_Size(flattened.ptr());
    for (Py_ssize_t i = 0; i < nelements; ++i) {
      *first++ = extract<std::string>(str(flattened[i]))();
    }
  }
};
 
template <typename DestElementType> struct CoerceType {
  NDArray operator()(const NDArray &x) {
    return x.astype(Converters::NDArrayTypeIndex<DestElementType>::typecode, false);
  }
};
 
template <> struct CoerceType<std::string> {
  object operator()(const NDArray &x) { return x; }
};
} // namespace
 
namespace Converters {
//-------------------------------------------------------------------------
// NDArrayToVector definitions
//-------------------------------------------------------------------------
 
template <typename DestElementType>
NDArrayToVector<DestElementType>::NDArrayToVector(const NDArray &value) : m_arr(CoerceType<DestElementType>()(value)) {}
 
template <typename DestElementType>
typename NDArrayToVector<DestElementType>::TypedVector NDArrayToVector<DestElementType>::operator()() {
  std::vector<DestElementType> cvector(PyArray_SIZE(reinterpret_cast<PyArrayObject *>(m_arr.ptr())));
  copyTo(cvector);
  return cvector;
}
 
template <typename DestElementType> void NDArrayToVector<DestElementType>::copyTo(TypedVector &dest) const {
  if (PyArray_SIZE(reinterpret_cast<PyArrayObject *>(m_arr.ptr())) > 0) {
    throwIfSizeMismatched(dest);
    CopyToImpl<DestElementType>()(std::begin(dest), reinterpret_cast<PyArrayObject *>(m_arr.ptr()));
  }
}
 
template <typename DestElementType>
void NDArrayToVector<DestElementType>::throwIfSizeMismatched(const TypedVector &dest) const {
  if (PyArray_SIZE(reinterpret_cast<PyArrayObject *>(m_arr.ptr())) ==
      static_cast<boost::python::ssize_t>(dest.size())) {
    return;
  } else {
    throw std::invalid_argument("Invalid number of elements while copying from ndarray. "
                                "ndarray=" +
                                std::to_string(PyArray_SIZE(reinterpret_cast<PyArrayObject *>(m_arr.ptr()))) +
                                " destination=(" + std::to_string(dest.size()) + ",)");
  }
}
 
//------------------------------------------------------------------------
// Explicit instantiations
//------------------------------------------------------------------------
#define INSTANTIATE_TOVECTOR(ElementType) template struct MANTID_PYTHONINTERFACE_CORE_DLL NDArrayToVector<ElementType>;
 
INSTANTIATE_TOVECTOR(int)
INSTANTIATE_TOVECTOR(long)
INSTANTIATE_TOVECTOR(long long)
INSTANTIATE_TOVECTOR(unsigned int)
INSTANTIATE_TOVECTOR(unsigned long)
INSTANTIATE_TOVECTOR(unsigned long long)
INSTANTIATE_TOVECTOR(float)
INSTANTIATE_TOVECTOR(double)
INSTANTIATE_TOVECTOR(bool)
INSTANTIATE_TOVECTOR(std::string)
} // namespace Converters
} // namespace Mantid::PythonInterface