40 #include <visp3/core/vpConfig.h>
41 #include <visp3/core/vpEigenConversion.h>
43 #if defined(VISP_HAVE_EIGEN3) && defined(VISP_HAVE_CATCH2)
44 #define CATCH_CONFIG_RUNNER
47 #ifdef ENABLE_VISP_NAMESPACE
53 template <
typename Type> std::ostream &operator<<(std::ostream &os,
const Eigen::Quaternion<Type> &q)
55 return os <<
"qw: " << q.w() <<
" ; qx: " << q.x() <<
" ; qy: " << q.y() <<
" ; qz: " << q.z();
58 template <
typename Type> std::ostream &operator<<(std::ostream &os,
const Eigen::AngleAxis<Type> &aa)
60 return os <<
"angle: " << aa.angle() <<
" ; axis: " << aa.axis()(0) <<
" ; " << aa.axis()(1) <<
" ; " << aa.axis()(2)
61 <<
" ; thetau: " << aa.angle() * aa.axis()(0) <<
" ; " << aa.angle() * aa.axis()(1) <<
" ; "
62 << aa.angle() * aa.axis()(2);
66 TEST_CASE(
"vpMatrix <--> Eigen::MatrixXd/Matrix3Xd conversion",
"[eigen_conversion]")
69 for (
unsigned int i = 0; i < visp_m.size(); i++) {
74 Eigen::MatrixXd eigen_m;
76 std::cout <<
"Eigen MatrixXd:\n" << eigen_m << std::endl;
80 std::cout <<
"ViSP vpMatrix:\n" << visp_m2 << std::endl;
82 REQUIRE(visp_m == visp_m2);
83 std::cout << std::endl;
86 Eigen::Matrix3Xd eigen_m;
88 std::cout <<
"Eigen Matrix3Xd:\n" << eigen_m << std::endl;
92 std::cout <<
"ViSP vpMatrix:\n" << visp_m2 << std::endl;
94 REQUIRE(visp_m == visp_m2);
95 std::cout << std::endl;
99 TEST_CASE(
"Eigen::MatrixXd <--> vpMatrix conversion",
"[eigen_conversion]")
101 Eigen::MatrixXd eigen_m(3, 5);
102 #if (VP_VERSION_INT(EIGEN_WORLD_VERSION, EIGEN_MAJOR_VERSION, EIGEN_MINOR_VERSION) < 0x030300)
103 for (Eigen::DenseIndex i = 0; i < eigen_m.rows(); i++) {
104 for (Eigen::DenseIndex j = 0; j < eigen_m.cols(); j++) {
106 for (Eigen::Index i = 0; i < eigen_m.rows(); i++) {
107 for (Eigen::Index j = 0; j < eigen_m.cols(); j++) {
109 eigen_m(i, j) =
static_cast<double>(i * eigen_m.cols() + j);
112 std::cout <<
"Eigen Matrix (row major: " << eigen_m.IsRowMajor <<
"):\n" << eigen_m << std::endl;
116 std::cout <<
"ViSP vpMatrix:\n" << visp_m << std::endl;
118 Eigen::MatrixXd eigen_m2;
120 std::cout <<
"Eigen MatrixXd (row major: " << eigen_m2.IsRowMajor <<
"):\n" << eigen_m2 << std::endl;
124 REQUIRE(visp_m == visp_m2);
125 std::cout << std::endl;
128 TEST_CASE(
"Eigen::MatrixX4d <--> vpMatrix conversion",
"[eigen_conversion]")
130 Eigen::MatrixX4d eigen_m(2, 4);
131 #if (VP_VERSION_INT(EIGEN_WORLD_VERSION, EIGEN_MAJOR_VERSION, EIGEN_MINOR_VERSION) < 0x030300)
132 for (Eigen::DenseIndex i = 0; i < eigen_m.rows(); i++) {
133 for (Eigen::DenseIndex j = 0; j < eigen_m.cols(); j++) {
135 for (Eigen::Index i = 0; i < eigen_m.rows(); i++) {
136 for (Eigen::Index j = 0; j < eigen_m.cols(); j++) {
138 eigen_m(i, j) =
static_cast<double>(i * eigen_m.cols() + j);
141 std::cout <<
"Eigen MatrixX4d (row major: " << eigen_m.IsRowMajor <<
"):\n" << eigen_m << std::endl;
145 std::cout <<
"ViSP vpMatrix:\n" << visp_m << std::endl;
147 Eigen::MatrixX4d eigen_m2;
149 std::cout <<
"Eigen MatrixX4d (row major: " << eigen_m2.IsRowMajor <<
"):\n" << eigen_m2 << std::endl;
153 REQUIRE(visp_m == visp_m2);
154 std::cout << std::endl;
157 TEST_CASE(
"Eigen::Matrix<double, Dynamic, Dynamic, RowMajor> <--> vpMatrix conversion",
"[eigen_conversion]")
159 Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> eigen_m(3, 5);
160 #if (VP_VERSION_INT(EIGEN_WORLD_VERSION, EIGEN_MAJOR_VERSION, EIGEN_MINOR_VERSION) < 0x030300)
161 for (Eigen::DenseIndex i = 0; i < eigen_m.rows(); i++) {
162 for (Eigen::DenseIndex j = 0; j < eigen_m.cols(); j++) {
164 for (Eigen::Index i = 0; i < eigen_m.rows(); i++) {
165 for (Eigen::Index j = 0; j < eigen_m.cols(); j++) {
167 eigen_m(i, j) =
static_cast<double>(i * eigen_m.cols() + j);
170 std::cout <<
"Eigen Matrix (RowMajor):\n" << eigen_m << std::endl;
174 std::cout <<
"ViSP vpMatrix:\n" << visp_m << std::endl;
176 Eigen::MatrixXd eigen_m2;
178 std::cout <<
"Eigen MatrixXd (row major: " << eigen_m2.IsRowMajor <<
"):\n" << eigen_m2 << std::endl;
182 REQUIRE(visp_m == visp_m2);
183 std::cout << std::endl;
186 TEST_CASE(
"Eigen::Matrix<double, Dynamic, Dynamic, ColMajor> <--> vpMatrix conversion",
"[eigen_conversion]")
188 Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor> eigen_m(3, 5);
189 #if (VP_VERSION_INT(EIGEN_WORLD_VERSION, EIGEN_MAJOR_VERSION, EIGEN_MINOR_VERSION) < 0x030300)
190 for (Eigen::DenseIndex i = 0; i < eigen_m.rows(); i++) {
191 for (Eigen::DenseIndex j = 0; j < eigen_m.cols(); j++) {
193 for (Eigen::Index i = 0; i < eigen_m.rows(); i++) {
194 for (Eigen::Index j = 0; j < eigen_m.cols(); j++) {
196 eigen_m(i, j) =
static_cast<double>(i * eigen_m.cols() + j);
199 std::cout <<
"Eigen Matrix (ColMajor):\n" << eigen_m << std::endl;
203 std::cout <<
"ViSP vpMatrix:\n" << visp_m << std::endl;
205 Eigen::MatrixXd eigen_m2;
207 std::cout <<
"Eigen MatrixXd (row major: " << eigen_m2.IsRowMajor <<
"):\n" << eigen_m2 << std::endl;
211 REQUIRE(visp_m == visp_m2);
212 std::cout << std::endl;
215 TEST_CASE(
"vpHomogeneousMatrix <--> Eigen::Matrix4d conversion",
"[eigen_conversion]")
218 Eigen::Matrix4d eigen_cMo;
220 std::cout <<
"Eigen Matrix4d cMo:\n" << eigen_cMo << std::endl;
224 std::cout <<
"ViSP vpHomogeneousMatrix cMo:\n" << visp_cMo2 << std::endl;
225 REQUIRE(visp_cMo == visp_cMo2);
226 std::cout << std::endl;
229 TEST_CASE(
"vpHomogeneousMatrix <--> Eigen::Matrix4f + double casting conversion",
"[eigen_conversion]")
232 Eigen::Matrix4d eigen_cMo_tmp;
234 Eigen::Matrix4f eigen_cMo = eigen_cMo_tmp.cast<
float>();
235 std::cout <<
"Eigen Matrix4f cMo:\n" << eigen_cMo << std::endl;
239 std::cout <<
"ViSP vpHomogeneousMatrix cMo:\n" << visp_cMo2 << std::endl;
240 REQUIRE(visp_cMo == visp_cMo2);
241 std::cout << std::endl;
244 TEST_CASE(
"vpQuaternionVector <--> Eigen::Quaternionf conversion",
"[eigen_conversion]")
247 Eigen::Quaternionf eigen_quaternion;
249 std::cout <<
"Eigen quaternion: " << eigen_quaternion << std::endl;
253 std::cout <<
"ViSP quaternion: " << visp_quaternion2.
t() << std::endl;
254 REQUIRE(visp_quaternion == visp_quaternion2);
255 std::cout << std::endl;
258 TEST_CASE(
"vpThetaUVector <--> Eigen::AngleAxisf conversion",
"[eigen_conversion]")
261 Eigen::AngleAxisf eigen_angle_axis;
263 std::cout <<
"Eigen AngleAxis: " << eigen_angle_axis << std::endl;
267 std::cout <<
"ViSP AngleAxis: " << visp_thetau2.
t() << std::endl;
268 REQUIRE(visp_thetau == visp_thetau2);
269 std::cout << std::endl;
272 TEST_CASE(
"vpColVector <--> Eigen::VectorXd conversion",
"[eigen_conversion]")
276 Eigen::VectorXd eigen_col;
278 std::cout <<
"Eigen VectorXd: " << eigen_col.transpose() << std::endl;
282 std::cout <<
"ViSP vpColVector: " << visp_col2.
t() << std::endl;
283 REQUIRE(visp_col == visp_col2);
284 std::cout << std::endl;
287 TEST_CASE(
"vpRowVector <--> Eigen::RowVectorXd conversion",
"[eigen_conversion]")
291 Eigen::RowVectorXd eigen_row;
293 std::cout <<
"Eigen RowVectorXd: " << eigen_row << std::endl;
297 std::cout <<
"ViSP vpRowVector: " << visp_row2 << std::endl;
298 REQUIRE(visp_row == visp_row2);
299 std::cout << std::endl;
302 TEST_CASE(
"Eigen::RowVector4d <--> vpRowVector conversion",
"[eigen_conversion]")
304 Eigen::RowVector4d eigen_row;
305 eigen_row << 9, 8, 7, 6;
308 std::cout <<
"ViSP vpRowVector: " << visp_row << std::endl;
310 Eigen::RowVector4d eigen_row2;
312 std::cout <<
"Eigen RowVector4d: " << eigen_row2 << std::endl;
316 REQUIRE(visp_row == visp_row2);
317 std::cout << std::endl;
320 TEST_CASE(
"vpRowVector <--> Eigen::RowVector4d conversion",
"[eigen_conversion]")
324 Eigen::RowVector4d eigen_row;
326 std::cout <<
"Eigen RowVector4d: " << eigen_row << std::endl;
330 std::cout <<
"ViSP vpRowVector: " << visp_row2 << std::endl;
331 REQUIRE(visp_row == visp_row2);
332 std::cout << std::endl;
335 int main(
int argc,
char *argv[])
337 Catch::Session session;
340 session.applyCommandLine(argc, argv);
342 int numFailed = session.run();
350 int main() {
return EXIT_SUCCESS; }
Implementation of column vector and the associated operations.
Implementation of an homogeneous matrix and operations on such kind of matrices.
Implementation of a matrix and operations on matrices.
Implementation of a rotation vector as quaternion angle minimal representation.
Implementation of row vector and the associated operations.
Implementation of a rotation vector as axis-angle minimal representation.
VISP_EXPORT void eigen2visp(const Eigen::MatrixXd &src, vpMatrix &dst)
void visp2eigen(const vpMatrix &src, Eigen::MatrixBase< Derived > &dst)