eigen-to-python.hpp

Go to the documentation of this file.

//
// Copyright (c) 2014-2023 CNRS INRIA
//
 
#ifndef __eigenpy_eigen_to_python_hpp__
#define __eigenpy_eigen_to_python_hpp__
 
#include <boost/type_traits.hpp>
 
#include "eigenpy/fwd.hpp"
 
#include "eigenpy/eigen-allocator.hpp"
#include "eigenpy/numpy-allocator.hpp"
#include "eigenpy/numpy-type.hpp"
#include "eigenpy/registration.hpp"
 
namespace boost {
namespace python {
 
template <typename MatrixRef, class MakeHolder>
struct to_python_indirect_eigen {
  template <class U>
  inline PyObject* operator()(U const& mat) const {
    return eigenpy::EigenToPy<MatrixRef>::convert(const_cast<U&>(mat));
  }
 
#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
  inline PyTypeObject const* get_pytype() const {
    return converter::registered_pytype<MatrixRef>::get_pytype();
  }
#endif
};
 
template <typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime,
          int Options, int MaxRowsAtCompileTime, int MaxColsAtCompileTime,
          class MakeHolder>
struct to_python_indirect<
    Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options,
                  MaxRowsAtCompileTime, MaxColsAtCompileTime>&,
    MakeHolder>
    : to_python_indirect_eigen<
          Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options,
                        MaxRowsAtCompileTime, MaxColsAtCompileTime>&,
          MakeHolder> {};
 
template <typename Scalar, int RowsAtCompileTime, int ColsAtCompileTime,
          int Options, int MaxRowsAtCompileTime, int MaxColsAtCompileTime,
          class MakeHolder>
struct to_python_indirect<
    const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime, Options,
                        MaxRowsAtCompileTime, MaxColsAtCompileTime>&,
    MakeHolder>
    : to_python_indirect_eigen<
          const Eigen::Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime,
                              Options, MaxRowsAtCompileTime,
                              MaxColsAtCompileTime>&,
          MakeHolder> {};
 
}  // namespace python
}  // namespace boost
 
namespace eigenpy {
 
EIGENPY_DOCUMENTATION_START_IGNORE
 
template <typename EigenType,
          typename BaseType = typename get_eigen_base_type<EigenType>::type>
struct eigen_to_py_impl;
 
template <typename MatType>
struct eigen_to_py_impl_matrix;
 
template <typename MatType>
struct eigen_to_py_impl<MatType, Eigen::MatrixBase<MatType> >
    : eigen_to_py_impl_matrix<MatType> {};
 
template <typename MatType>
struct eigen_to_py_impl<MatType&, Eigen::MatrixBase<MatType> >
    : eigen_to_py_impl_matrix<MatType&> {};
 
template <typename MatType>
struct eigen_to_py_impl<const MatType, const Eigen::MatrixBase<MatType> >
    : eigen_to_py_impl_matrix<const MatType> {};
 
template <typename MatType>
struct eigen_to_py_impl<const MatType&, const Eigen::MatrixBase<MatType> >
    : eigen_to_py_impl_matrix<const MatType&> {};
 
template <typename MatType>
struct eigen_to_py_impl_matrix {
  static PyObject* convert(
      typename boost::add_reference<
          typename boost::add_const<MatType>::type>::type mat) {
    typedef typename boost::remove_const<
        typename boost::remove_reference<MatType>::type>::type MatrixDerived;
 
    assert((mat.rows() < INT_MAX) && (mat.cols() < INT_MAX) &&
           "Matrix range larger than int ... should never happen.");
    const npy_intp R = (npy_intp)mat.rows(), C = (npy_intp)mat.cols();
 
    PyArrayObject* pyArray;
    // Allocate Python memory
    if ((((!(C == 1) != !(R == 1)) && !MatrixDerived::IsVectorAtCompileTime) ||
         MatrixDerived::IsVectorAtCompileTime))  // Handle array with a single
                                                 // dimension
    {
      npy_intp shape[1] = {C == 1 ? R : C};
      pyArray = NumpyAllocator<MatType>::allocate(
          const_cast<MatrixDerived&>(mat.derived()), 1, shape);
    } else {
      npy_intp shape[2] = {R, C};
      pyArray = NumpyAllocator<MatType>::allocate(
          const_cast<MatrixDerived&>(mat.derived()), 2, shape);
    }
 
    // Create an instance (either np.array or np.matrix)
    return NumpyType::make(pyArray).ptr();
  }
};
 
#ifdef EIGENPY_WITH_TENSOR_SUPPORT
template <typename TensorType>
struct eigen_to_py_impl_tensor;
 
template <typename TensorType>
struct eigen_to_py_impl<TensorType, Eigen::TensorBase<TensorType> >
    : eigen_to_py_impl_tensor<TensorType> {};
 
template <typename TensorType>
struct eigen_to_py_impl<const TensorType, const Eigen::TensorBase<TensorType> >
    : eigen_to_py_impl_tensor<const TensorType> {};
 
template <typename TensorType>
struct eigen_to_py_impl_tensor {
  static PyObject* convert(
      typename boost::add_reference<
          typename boost::add_const<TensorType>::type>::type tensor) {
    //    typedef typename boost::remove_const<
    //        typename boost::remove_reference<Tensor>::type>::type
    //        TensorDerived;
 
    static const int NumIndices = TensorType::NumIndices;
    npy_intp shape[NumIndices];
    for (int k = 0; k < NumIndices; ++k) shape[k] = tensor.dimension(k);
 
    PyArrayObject* pyArray = NumpyAllocator<TensorType>::allocate(
        const_cast<TensorType&>(tensor), NumIndices, shape);
 
    // Create an instance (either np.array or np.matrix)
    return NumpyType::make(pyArray).ptr();
  }
};
#endif
 
EIGENPY_DOCUMENTATION_END_IGNORE
 
#ifdef EIGENPY_MSVC_COMPILER
template <typename EigenType>
struct EigenToPy<EigenType,
                 typename boost::remove_reference<EigenType>::type::Scalar>
#else
template <typename EigenType, typename _Scalar>
struct EigenToPy
#endif
    : eigen_to_py_impl<EigenType> {
  static PyTypeObject const* get_pytype() { return getPyArrayType(); }
};
 
template <typename MatType>
struct EigenToPyConverter {
  static void registration() {
    bp::to_python_converter<MatType, EigenToPy<MatType>, true>();
  }
};
}  // namespace eigenpy
 
#endif  // __eigenpy_eigen_to_python_hpp__