switched to MatrixXd for all wrappers, updated pybind11
Former-commit-id: 332266c090
This commit is contained in:
Daniele Panozzo
+254
-241
@@ -3,223 +3,223 @@
|
||||
|
||||
#include "python.h"
|
||||
|
||||
template <typename Type> void init_fixed_from_buffer_3(Type &v, py::buffer &b) {
|
||||
typedef typename Type::Scalar Scalar;
|
||||
|
||||
py::buffer_info info = b.request();
|
||||
if (info.format != py::format_descriptor<Scalar>::value())
|
||||
throw std::runtime_error("Incompatible buffer format!");
|
||||
if (!((info.ndim == 1 && info.strides[0] == sizeof(Scalar)) ||
|
||||
(info.ndim == 2 &&
|
||||
((info.shape[0] == 1 && info.strides[0] == sizeof(Scalar) &&
|
||||
info.shape[1] == 3) ||
|
||||
(info.shape[1] == 1 && info.strides[1] == sizeof(Scalar) &&
|
||||
info.shape[0] == 3)))))
|
||||
throw std::runtime_error("Incompatible buffer dimension!");
|
||||
|
||||
memcpy(v.data(), info.ptr, sizeof(Scalar) * 3);
|
||||
}
|
||||
|
||||
/// Creates Python bindings for an Eigen order-1 tensor of size 3 (i.e. a vector/normal/point)
|
||||
template <typename Type>
|
||||
py::class_<Type> bind_eigen_1_3(py::module &m, const char *name,
|
||||
py::object parent = py::object()) {
|
||||
typedef typename Type::Scalar Scalar;
|
||||
|
||||
py::class_<Type> vector(m, name, parent);
|
||||
vector
|
||||
/* Constructors */
|
||||
.def(py::init<>())
|
||||
.def(py::init<Scalar>())
|
||||
.def(py::init<Scalar, Scalar, Scalar>())
|
||||
.def("__init__", [](Type &v, const std::vector<Scalar> &v2) {
|
||||
if (v2.size() != 3)
|
||||
throw std::runtime_error("Incompatible size!");
|
||||
memcpy(v.data(), &v2[0], sizeof(Scalar) * 3);
|
||||
})
|
||||
.def("__init__", [](Type &v, py::buffer b) {
|
||||
init_fixed_from_buffer_3(v, b);
|
||||
})
|
||||
|
||||
/* Initialization */
|
||||
.def("setConstant", [](Type &m, Scalar value) { m.setConstant(value); })
|
||||
.def("setZero", [](Type &m) { m.setZero(); })
|
||||
|
||||
/* Arithmetic operators (def_cast forcefully casts the result back to a
|
||||
Matrix to avoid type issues with Eigen's crazy expression templates) */
|
||||
.def_cast(-py::self)
|
||||
.def_cast(py::self + py::self)
|
||||
.def_cast(py::self - py::self)
|
||||
.def_cast(py::self * Scalar())
|
||||
.def_cast(py::self / Scalar())
|
||||
.def_cast(py::self += py::self)
|
||||
.def_cast(py::self -= py::self)
|
||||
.def_cast(py::self *= Scalar())
|
||||
.def_cast(py::self /= Scalar())
|
||||
|
||||
/* Comparison operators */
|
||||
.def(py::self == py::self)
|
||||
.def(py::self != py::self)
|
||||
|
||||
/* Python protocol implementations */
|
||||
.def("__len__", [](const Type &) { return (int) 3; })
|
||||
.def("__repr__", [](const Type &v) {
|
||||
std::ostringstream oss;
|
||||
oss << v;
|
||||
return oss.str();
|
||||
})
|
||||
.def("__getitem__", [](const Type &c, int i) {
|
||||
if (i < 0 || i >= 3)
|
||||
throw py::index_error();
|
||||
return c[i];
|
||||
})
|
||||
.def("__setitem__", [](Type &c, int i, Scalar v) {
|
||||
if (i < 0 || i >= 3)
|
||||
throw py::index_error();
|
||||
c[i] = v;
|
||||
})
|
||||
|
||||
/* Buffer access for interacting with NumPy */
|
||||
.def_buffer([](Type &m) -> py::buffer_info {
|
||||
return py::buffer_info(
|
||||
m.data(), /* Pointer to buffer */
|
||||
sizeof(Scalar), /* Size of one scalar */
|
||||
/* Python struct-style format descriptor */
|
||||
py::format_descriptor<Scalar>::value(),
|
||||
1, { (size_t) 3 },
|
||||
{ sizeof(Scalar) }
|
||||
);
|
||||
});
|
||||
return vector;
|
||||
}
|
||||
|
||||
/// Creates Python bindings for a dynamic Eigen order-1 tensor (i.e. a vector)
|
||||
template <typename Type>
|
||||
py::class_<Type> bind_eigen_1(py::module &m, const char *name,
|
||||
py::object parent = py::object()) {
|
||||
typedef typename Type::Scalar Scalar;
|
||||
|
||||
/* Many Eigen functions are templated and can't easily be referenced using
|
||||
a function pointer, thus a big portion of the binding code below
|
||||
instantiates Eigen code using small anonymous wrapper functions */
|
||||
py::class_<Type> vector(m, name, parent);
|
||||
|
||||
vector
|
||||
/* Constructors */
|
||||
.def(py::init<>())
|
||||
.def(py::init<size_t>())
|
||||
.def("__init__", [](Type &v, const std::vector<Scalar> &v2) {
|
||||
new (&v) Type(v2.size());
|
||||
memcpy(v.data(), &v2[0], sizeof(Scalar) * v2.size());
|
||||
})
|
||||
.def("__init__", [](Type &v, py::buffer b) {
|
||||
py::buffer_info info = b.request();
|
||||
if (info.format != py::format_descriptor<Scalar>::value()) {
|
||||
throw std::runtime_error("Incompatible buffer format!");
|
||||
} else if (info.ndim == 1 && info.strides[0] == sizeof(Scalar)) {
|
||||
new (&v) Type(info.shape[0]);
|
||||
memcpy(v.data(), info.ptr, sizeof(Scalar) * info.shape[0]);
|
||||
} else if (info.ndim == 2 && ((info.shape[0] == 1 && info.strides[0] == sizeof(Scalar))
|
||||
|| (info.shape[1] == 1 && info.strides[1] == sizeof(Scalar)))) {
|
||||
new (&v) Type(info.shape[0] * info.shape[1]);
|
||||
memcpy(v.data(), info.ptr, sizeof(Scalar) * info.shape[0] * info.shape[1]);
|
||||
} else {
|
||||
throw std::runtime_error("Incompatible buffer dimension!");
|
||||
}
|
||||
})
|
||||
|
||||
/* Size query functions */
|
||||
.def("size", [](const Type &m) { return m.size(); })
|
||||
.def("cols", [](const Type &m) { return m.cols(); })
|
||||
.def("rows", [](const Type &m) { return m.rows(); })
|
||||
|
||||
/* Initialization */
|
||||
.def("setZero", [](Type &m) { m.setZero(); })
|
||||
.def("setConstant", [](Type &m, Scalar value) { m.setConstant(value); })
|
||||
|
||||
/* Resizing */
|
||||
.def("resize", [](Type &m, size_t s0) { m.resize(s0); })
|
||||
.def("resizeLike", [](Type &m, const Type &m2) { m.resizeLike(m2); })
|
||||
.def("conservativeResize", [](Type &m, size_t s0) { m.conservativeResize(s0); })
|
||||
|
||||
/* Component-wise operations */
|
||||
.def("cwiseAbs", &Type::cwiseAbs)
|
||||
.def("cwiseAbs2", &Type::cwiseAbs2)
|
||||
.def("cwiseSqrt", &Type::cwiseSqrt)
|
||||
.def("cwiseInverse", &Type::cwiseInverse)
|
||||
.def("cwiseMin", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseMin(m2); })
|
||||
.def("cwiseMax", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseMax(m2); })
|
||||
.def("cwiseMin", [](const Type &m1, Scalar s) -> Type { return m1.cwiseMin(s); })
|
||||
.def("cwiseMax", [](const Type &m1, Scalar s) -> Type { return m1.cwiseMax(s); })
|
||||
.def("cwiseProduct", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseProduct(m2); })
|
||||
.def("cwiseQuotient", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseQuotient(m2); })
|
||||
|
||||
/* Arithmetic operators (def_cast forcefully casts the result back to a
|
||||
Type to avoid type issues with Eigen's crazy expression templates) */
|
||||
.def_cast(-py::self)
|
||||
.def_cast(py::self + py::self)
|
||||
.def_cast(py::self - py::self)
|
||||
.def_cast(py::self * Scalar())
|
||||
.def_cast(py::self / Scalar())
|
||||
|
||||
.def("__rmul__", [](const Type& a, const Scalar& b)
|
||||
{
|
||||
return Type(b * a);
|
||||
})
|
||||
|
||||
|
||||
/* Arithmetic in-place operators */
|
||||
.def_cast(py::self += py::self)
|
||||
.def_cast(py::self -= py::self)
|
||||
.def_cast(py::self *= py::self)
|
||||
.def_cast(py::self *= Scalar())
|
||||
.def_cast(py::self /= Scalar())
|
||||
|
||||
/* Comparison operators */
|
||||
.def(py::self == py::self)
|
||||
.def(py::self != py::self)
|
||||
|
||||
/* Python protocol implementations */
|
||||
.def("__repr__", [](const Type &v) {
|
||||
std::ostringstream oss;
|
||||
oss << v.transpose();
|
||||
return oss.str();
|
||||
})
|
||||
.def("__getitem__", [](const Type &m, size_t i) {
|
||||
if (i >= (size_t) m.size())
|
||||
throw py::index_error();
|
||||
return m[i];
|
||||
})
|
||||
.def("__setitem__", [](Type &m, size_t i, Scalar v) {
|
||||
if (i >= (size_t) m.size())
|
||||
throw py::index_error();
|
||||
m[i] = v;
|
||||
})
|
||||
|
||||
/* Buffer access for interacting with NumPy */
|
||||
.def_buffer([](Type &m) -> py::buffer_info {
|
||||
return py::buffer_info(
|
||||
m.data(), /* Pointer to buffer */
|
||||
sizeof(Scalar), /* Size of one scalar */
|
||||
/* Python struct-style format descriptor */
|
||||
py::format_descriptor<Scalar>::value(),
|
||||
1, /* Number of dimensions */
|
||||
{ (size_t) m.size() }, /* Buffer dimensions */
|
||||
{ sizeof(Scalar) } /* Strides (in bytes) for each index */
|
||||
);
|
||||
})
|
||||
|
||||
/* Static initializers */
|
||||
.def_static("Zero", [](size_t n) { return Type(Type::Zero(n)); })
|
||||
.def_static("Ones", [](size_t n) { return Type(Type::Ones(n)); })
|
||||
.def_static("Constant", [](size_t n, Scalar value) { return Type(Type::Constant(n, value)); })
|
||||
.def("MapMatrix", [](const Type& m, size_t r, size_t c)
|
||||
{
|
||||
return Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic>(Eigen::Map<const Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic>>(m.data(),r,c));
|
||||
})
|
||||
;
|
||||
return vector;
|
||||
}
|
||||
// template <typename Type> void init_fixed_from_buffer_3(Type &v, py::buffer &b) {
|
||||
// typedef typename Type::Scalar Scalar;
|
||||
//
|
||||
// py::buffer_info info = b.request();
|
||||
// if (info.format != py::format_descriptor<Scalar>::value())
|
||||
// throw std::runtime_error("Incompatible buffer format!");
|
||||
// if (!((info.ndim == 1 && info.strides[0] == sizeof(Scalar)) ||
|
||||
// (info.ndim == 2 &&
|
||||
// ((info.shape[0] == 1 && info.strides[0] == sizeof(Scalar) &&
|
||||
// info.shape[1] == 3) ||
|
||||
// (info.shape[1] == 1 && info.strides[1] == sizeof(Scalar) &&
|
||||
// info.shape[0] == 3)))))
|
||||
// throw std::runtime_error("Incompatible buffer dimension!");
|
||||
//
|
||||
// memcpy(v.data(), info.ptr, sizeof(Scalar) * 3);
|
||||
// }
|
||||
//
|
||||
// /// Creates Python bindings for an Eigen order-1 tensor of size 3 (i.e. a vector/normal/point)
|
||||
// template <typename Type>
|
||||
// py::class_<Type> bind_eigen_1_3(py::module &m, const char *name,
|
||||
// py::object parent = py::object()) {
|
||||
// typedef typename Type::Scalar Scalar;
|
||||
//
|
||||
// py::class_<Type> vector(m, name, parent);
|
||||
// vector
|
||||
// /* Constructors */
|
||||
// .def(py::init<>())
|
||||
// .def(py::init<Scalar>())
|
||||
// .def(py::init<Scalar, Scalar, Scalar>())
|
||||
// .def("__init__", [](Type &v, const std::vector<Scalar> &v2) {
|
||||
// if (v2.size() != 3)
|
||||
// throw std::runtime_error("Incompatible size!");
|
||||
// memcpy(v.data(), &v2[0], sizeof(Scalar) * 3);
|
||||
// })
|
||||
// .def("__init__", [](Type &v, py::buffer b) {
|
||||
// init_fixed_from_buffer_3(v, b);
|
||||
// })
|
||||
//
|
||||
// /* Initialization */
|
||||
// .def("setConstant", [](Type &m, Scalar value) { m.setConstant(value); })
|
||||
// .def("setZero", [](Type &m) { m.setZero(); })
|
||||
//
|
||||
// /* Arithmetic operators (def_cast forcefully casts the result back to a
|
||||
// Matrix to avoid type issues with Eigen's crazy expression templates) */
|
||||
// .def_cast(-py::self)
|
||||
// .def_cast(py::self + py::self)
|
||||
// .def_cast(py::self - py::self)
|
||||
// .def_cast(py::self * Scalar())
|
||||
// .def_cast(py::self / Scalar())
|
||||
// .def_cast(py::self += py::self)
|
||||
// .def_cast(py::self -= py::self)
|
||||
// .def_cast(py::self *= Scalar())
|
||||
// .def_cast(py::self /= Scalar())
|
||||
//
|
||||
// /* Comparison operators */
|
||||
// .def(py::self == py::self)
|
||||
// .def(py::self != py::self)
|
||||
//
|
||||
// /* Python protocol implementations */
|
||||
// .def("__len__", [](const Type &) { return (int) 3; })
|
||||
// .def("__repr__", [](const Type &v) {
|
||||
// std::ostringstream oss;
|
||||
// oss << v;
|
||||
// return oss.str();
|
||||
// })
|
||||
// .def("__getitem__", [](const Type &c, int i) {
|
||||
// if (i < 0 || i >= 3)
|
||||
// throw py::index_error();
|
||||
// return c[i];
|
||||
// })
|
||||
// .def("__setitem__", [](Type &c, int i, Scalar v) {
|
||||
// if (i < 0 || i >= 3)
|
||||
// throw py::index_error();
|
||||
// c[i] = v;
|
||||
// })
|
||||
//
|
||||
// /* Buffer access for interacting with NumPy */
|
||||
// .def_buffer([](Type &m) -> py::buffer_info {
|
||||
// return py::buffer_info(
|
||||
// m.data(), /* Pointer to buffer */
|
||||
// sizeof(Scalar), /* Size of one scalar */
|
||||
// /* Python struct-style format descriptor */
|
||||
// py::format_descriptor<Scalar>::value(),
|
||||
// 1, { (size_t) 3 },
|
||||
// { sizeof(Scalar) }
|
||||
// );
|
||||
// });
|
||||
// return vector;
|
||||
// }
|
||||
//
|
||||
// /// Creates Python bindings for a dynamic Eigen order-1 tensor (i.e. a vector)
|
||||
// template <typename Type>
|
||||
// py::class_<Type> bind_eigen_1(py::module &m, const char *name,
|
||||
// py::object parent = py::object()) {
|
||||
// typedef typename Type::Scalar Scalar;
|
||||
//
|
||||
// /* Many Eigen functions are templated and can't easily be referenced using
|
||||
// a function pointer, thus a big portion of the binding code below
|
||||
// instantiates Eigen code using small anonymous wrapper functions */
|
||||
// py::class_<Type> vector(m, name, parent);
|
||||
//
|
||||
// vector
|
||||
// /* Constructors */
|
||||
// .def(py::init<>())
|
||||
// .def(py::init<size_t>())
|
||||
// .def("__init__", [](Type &v, const std::vector<Scalar> &v2) {
|
||||
// new (&v) Type(v2.size());
|
||||
// memcpy(v.data(), &v2[0], sizeof(Scalar) * v2.size());
|
||||
// })
|
||||
// .def("__init__", [](Type &v, py::buffer b) {
|
||||
// py::buffer_info info = b.request();
|
||||
// if (info.format != py::format_descriptor<Scalar>::value()) {
|
||||
// throw std::runtime_error("Incompatible buffer format!");
|
||||
// } else if (info.ndim == 1 && info.strides[0] == sizeof(Scalar)) {
|
||||
// new (&v) Type(info.shape[0]);
|
||||
// memcpy(v.data(), info.ptr, sizeof(Scalar) * info.shape[0]);
|
||||
// } else if (info.ndim == 2 && ((info.shape[0] == 1 && info.strides[0] == sizeof(Scalar))
|
||||
// || (info.shape[1] == 1 && info.strides[1] == sizeof(Scalar)))) {
|
||||
// new (&v) Type(info.shape[0] * info.shape[1]);
|
||||
// memcpy(v.data(), info.ptr, sizeof(Scalar) * info.shape[0] * info.shape[1]);
|
||||
// } else {
|
||||
// throw std::runtime_error("Incompatible buffer dimension!");
|
||||
// }
|
||||
// })
|
||||
//
|
||||
// /* Size query functions */
|
||||
// .def("size", [](const Type &m) { return m.size(); })
|
||||
// .def("cols", [](const Type &m) { return m.cols(); })
|
||||
// .def("rows", [](const Type &m) { return m.rows(); })
|
||||
//
|
||||
// /* Initialization */
|
||||
// .def("setZero", [](Type &m) { m.setZero(); })
|
||||
// .def("setConstant", [](Type &m, Scalar value) { m.setConstant(value); })
|
||||
//
|
||||
// /* Resizing */
|
||||
// .def("resize", [](Type &m, size_t s0) { m.resize(s0); })
|
||||
// .def("resizeLike", [](Type &m, const Type &m2) { m.resizeLike(m2); })
|
||||
// .def("conservativeResize", [](Type &m, size_t s0) { m.conservativeResize(s0); })
|
||||
//
|
||||
// /* Component-wise operations */
|
||||
// .def("cwiseAbs", &Type::cwiseAbs)
|
||||
// .def("cwiseAbs2", &Type::cwiseAbs2)
|
||||
// .def("cwiseSqrt", &Type::cwiseSqrt)
|
||||
// .def("cwiseInverse", &Type::cwiseInverse)
|
||||
// .def("cwiseMin", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseMin(m2); })
|
||||
// .def("cwiseMax", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseMax(m2); })
|
||||
// .def("cwiseMin", [](const Type &m1, Scalar s) -> Type { return m1.cwiseMin(s); })
|
||||
// .def("cwiseMax", [](const Type &m1, Scalar s) -> Type { return m1.cwiseMax(s); })
|
||||
// .def("cwiseProduct", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseProduct(m2); })
|
||||
// .def("cwiseQuotient", [](const Type &m1, const Type &m2) -> Type { return m1.cwiseQuotient(m2); })
|
||||
//
|
||||
// /* Arithmetic operators (def_cast forcefully casts the result back to a
|
||||
// Type to avoid type issues with Eigen's crazy expression templates) */
|
||||
// .def_cast(-py::self)
|
||||
// .def_cast(py::self + py::self)
|
||||
// .def_cast(py::self - py::self)
|
||||
// .def_cast(py::self * Scalar())
|
||||
// .def_cast(py::self / Scalar())
|
||||
//
|
||||
// .def("__rmul__", [](const Type& a, const Scalar& b)
|
||||
// {
|
||||
// return Type(b * a);
|
||||
// })
|
||||
//
|
||||
//
|
||||
// /* Arithmetic in-place operators */
|
||||
// .def_cast(py::self += py::self)
|
||||
// .def_cast(py::self -= py::self)
|
||||
// .def_cast(py::self *= py::self)
|
||||
// .def_cast(py::self *= Scalar())
|
||||
// .def_cast(py::self /= Scalar())
|
||||
//
|
||||
// /* Comparison operators */
|
||||
// .def(py::self == py::self)
|
||||
// .def(py::self != py::self)
|
||||
//
|
||||
// /* Python protocol implementations */
|
||||
// .def("__repr__", [](const Type &v) {
|
||||
// std::ostringstream oss;
|
||||
// oss << v.transpose();
|
||||
// return oss.str();
|
||||
// })
|
||||
// .def("__getitem__", [](const Type &m, size_t i) {
|
||||
// if (i >= (size_t) m.size())
|
||||
// throw py::index_error();
|
||||
// return m[i];
|
||||
// })
|
||||
// .def("__setitem__", [](Type &m, size_t i, Scalar v) {
|
||||
// if (i >= (size_t) m.size())
|
||||
// throw py::index_error();
|
||||
// m[i] = v;
|
||||
// })
|
||||
//
|
||||
// /* Buffer access for interacting with NumPy */
|
||||
// .def_buffer([](Type &m) -> py::buffer_info {
|
||||
// return py::buffer_info(
|
||||
// m.data(), /* Pointer to buffer */
|
||||
// sizeof(Scalar), /* Size of one scalar */
|
||||
// /* Python struct-style format descriptor */
|
||||
// py::format_descriptor<Scalar>::value(),
|
||||
// 1, /* Number of dimensions */
|
||||
// { (size_t) m.size() }, /* Buffer dimensions */
|
||||
// { sizeof(Scalar) } /* Strides (in bytes) for each index */
|
||||
// );
|
||||
// })
|
||||
//
|
||||
// /* Static initializers */
|
||||
// .def_static("Zero", [](size_t n) { return Type(Type::Zero(n)); })
|
||||
// .def_static("Ones", [](size_t n) { return Type(Type::Ones(n)); })
|
||||
// .def_static("Constant", [](size_t n, Scalar value) { return Type(Type::Constant(n, value)); })
|
||||
// .def("MapMatrix", [](const Type& m, size_t r, size_t c)
|
||||
// {
|
||||
// return Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic>(Eigen::Map<const Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic>>(m.data(),r,c));
|
||||
// })
|
||||
// ;
|
||||
// return vector;
|
||||
// }
|
||||
|
||||
/// Creates Python bindings for a dynamic Eigen order-2 tensor (i.e. a matrix)
|
||||
template <typename Type>
|
||||
@@ -266,6 +266,19 @@ py::class_<Type> bind_eigen_2(py::module &m, const char *name,
|
||||
.def("cols", [](const Type &m) { return m.cols(); })
|
||||
.def("rows", [](const Type &m) { return m.rows(); })
|
||||
|
||||
/* Extract rows and colums */
|
||||
.def("col", [](const Type &m, int i) {
|
||||
if (i<0 || i>=m.cols())
|
||||
throw std::runtime_error("Column index out of bound.");
|
||||
return Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic>(m.col(i));
|
||||
})
|
||||
.def("row", [](const Type &m, int i) {
|
||||
if (i<0 || i>=m.rows())
|
||||
throw std::runtime_error("Row index out of bound.");
|
||||
return Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic>(m.row(i));
|
||||
})
|
||||
|
||||
|
||||
/* Initialization */
|
||||
.def("setZero", [](Type &m) { m.setZero(); })
|
||||
.def("setIdentity", [](Type &m) { m.setIdentity(); })
|
||||
@@ -565,14 +578,14 @@ void python_export_vector(py::module &m) {
|
||||
"eigen", "Wrappers for Eigen types");
|
||||
|
||||
/* Bindings for VectorXd */
|
||||
bind_eigen_1<Eigen::VectorXd> (me, "VectorXd");
|
||||
py::implicitly_convertible<py::buffer, Eigen::VectorXd>();
|
||||
py::implicitly_convertible<double, Eigen::VectorXd>();
|
||||
// bind_eigen_1<Eigen::VectorXd> (me, "VectorXd");
|
||||
// py::implicitly_convertible<py::buffer, Eigen::VectorXd>();
|
||||
// py::implicitly_convertible<double, Eigen::VectorXd>();
|
||||
|
||||
/* Bindings for VectorXi */
|
||||
bind_eigen_1<Eigen::VectorXi> (me, "VectorXi");
|
||||
py::implicitly_convertible<py::buffer, Eigen::VectorXi>();
|
||||
py::implicitly_convertible<double, Eigen::VectorXi>();
|
||||
// bind_eigen_1<Eigen::VectorXi> (me, "VectorXi");
|
||||
// py::implicitly_convertible<py::buffer, Eigen::VectorXi>();
|
||||
// py::implicitly_convertible<double, Eigen::VectorXi>();
|
||||
|
||||
/* Bindings for MatrixXd */
|
||||
bind_eigen_2<Eigen::MatrixXd> (me, "MatrixXd");
|
||||
@@ -584,24 +597,24 @@ void python_export_vector(py::module &m) {
|
||||
py::implicitly_convertible<py::buffer, Eigen::MatrixXi>();
|
||||
py::implicitly_convertible<double, Eigen::MatrixXi>();
|
||||
|
||||
/* Bindings for Vector3d */
|
||||
auto vector3 = bind_eigen_1_3<Eigen::Vector3d>(me, "Vector3d");
|
||||
vector3
|
||||
.def("norm", [](const Eigen::Vector3d &v) { return v.norm(); })
|
||||
.def("squaredNorm", [](const Eigen::Vector3d &v) { return v.squaredNorm(); })
|
||||
.def("normalize", [](Eigen::Vector3d &v) { v.normalize(); })
|
||||
.def("normalized", [](const Eigen::Vector3d &v) -> Eigen::Vector3d { return v.normalized(); })
|
||||
.def("dot", [](const Eigen::Vector3d &v1, const Eigen::Vector3d &v2) { return v1.dot(v2); })
|
||||
.def("cross", [](const Eigen::Vector3d &v1, const Eigen::Vector3d &v2) -> Eigen::Vector3d { return v1.cross(v2); })
|
||||
.def_property("x", [](const Eigen::Vector3d &v) -> double { return v.x(); },
|
||||
[](Eigen::Vector3d &v, double x) { v.x() = x; }, "X coordinate")
|
||||
.def_property("y", [](const Eigen::Vector3d &v) -> double { return v.y(); },
|
||||
[](Eigen::Vector3d &v, double y) { v.y() = y; }, "Y coordinate")
|
||||
.def_property("z", [](const Eigen::Vector3d &v) -> double { return v.z(); },
|
||||
[](Eigen::Vector3d &v, double z) { v.z() = z; }, "Z coordinate");
|
||||
|
||||
py::implicitly_convertible<py::buffer, Eigen::Vector3d>();
|
||||
py::implicitly_convertible<double, Eigen::Vector3d>();
|
||||
// /* Bindings for Vector3d */
|
||||
// auto vector3 = bind_eigen_1_3<Eigen::Vector3d>(me, "Vector3d");
|
||||
// vector3
|
||||
// .def("norm", [](const Eigen::Vector3d &v) { return v.norm(); })
|
||||
// .def("squaredNorm", [](const Eigen::Vector3d &v) { return v.squaredNorm(); })
|
||||
// .def("normalize", [](Eigen::Vector3d &v) { v.normalize(); })
|
||||
// .def("normalized", [](const Eigen::Vector3d &v) -> Eigen::Vector3d { return v.normalized(); })
|
||||
// .def("dot", [](const Eigen::Vector3d &v1, const Eigen::Vector3d &v2) { return v1.dot(v2); })
|
||||
// .def("cross", [](const Eigen::Vector3d &v1, const Eigen::Vector3d &v2) -> Eigen::Vector3d { return v1.cross(v2); })
|
||||
// .def_property("x", [](const Eigen::Vector3d &v) -> double { return v.x(); },
|
||||
// [](Eigen::Vector3d &v, double x) { v.x() = x; }, "X coordinate")
|
||||
// .def_property("y", [](const Eigen::Vector3d &v) -> double { return v.y(); },
|
||||
// [](Eigen::Vector3d &v, double y) { v.y() = y; }, "Y coordinate")
|
||||
// .def_property("z", [](const Eigen::Vector3d &v) -> double { return v.z(); },
|
||||
// [](Eigen::Vector3d &v, double z) { v.z() = z; }, "Z coordinate");
|
||||
//
|
||||
// py::implicitly_convertible<py::buffer, Eigen::Vector3d>();
|
||||
// py::implicitly_convertible<double, Eigen::Vector3d>();
|
||||
|
||||
/* Bindings for SparseMatrix<double> */
|
||||
bind_eigen_sparse_2< Eigen::SparseMatrix<double> > (me, "SparseMatrixd");
|
||||
|
||||
Reference in New Issue
Block a user