aboutsummaryrefslogtreecommitdiff
path: root/test/geo_transformations.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'test/geo_transformations.cpp')
-rwxr-xr-x[-rw-r--r--]test/geo_transformations.cpp91
1 files changed, 68 insertions, 23 deletions
diff --git a/test/geo_transformations.cpp b/test/geo_transformations.cpp
index 4ad3793d8..278e527c2 100644..100755
--- a/test/geo_transformations.cpp
+++ b/test/geo_transformations.cpp
@@ -12,6 +12,17 @@
#include <Eigen/LU>
#include <Eigen/SVD>
+template<typename T>
+Matrix<T,2,1> angleToVec(T a)
+{
+ return Matrix<T,2,1>(std::cos(a), std::sin(a));
+}
+
+// This permits to workaround a bug in clang/llvm code generation.
+template<typename T>
+EIGEN_DONT_INLINE
+void dont_over_optimize(T& x) { volatile typename T::Scalar tmp = x(0); x(0) = tmp; }
+
template<typename Scalar, int Mode, int Options> void non_projective_only()
{
/* this test covers the following files:
@@ -29,7 +40,7 @@ template<typename Scalar, int Mode, int Options> void non_projective_only()
Transform3 t0, t1, t2;
- Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
+ Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
Quaternionx q1, q2;
@@ -97,16 +108,14 @@ template<typename Scalar, int Mode, int Options> void transformations()
v1 = Vector3::Random();
Matrix3 matrot1, m;
- Scalar a = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
- Scalar s0 = internal::random<Scalar>(),
- s1 = internal::random<Scalar>();
+ Scalar a = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
+ Scalar s0 = internal::random<Scalar>(), s1 = internal::random<Scalar>();
while(v0.norm() < test_precision<Scalar>()) v0 = Vector3::Random();
while(v1.norm() < test_precision<Scalar>()) v1 = Vector3::Random();
-
VERIFY_IS_APPROX(v0, AngleAxisx(a, v0.normalized()) * v0);
- VERIFY_IS_APPROX(-v0, AngleAxisx(Scalar(M_PI), v0.unitOrthogonal()) * v0);
+ VERIFY_IS_APPROX(-v0, AngleAxisx(Scalar(EIGEN_PI), v0.unitOrthogonal()) * v0);
if(abs(cos(a)) > test_precision<Scalar>())
{
VERIFY_IS_APPROX(cos(a)*v0.squaredNorm(), v0.dot(AngleAxisx(a, v0.unitOrthogonal()) * v0));
@@ -132,14 +141,16 @@ template<typename Scalar, int Mode, int Options> void transformations()
AngleAxisx aa = AngleAxisx(q1);
VERIFY_IS_APPROX(q1 * v1, Quaternionx(aa) * v1);
- if(abs(aa.angle()) > NumTraits<Scalar>::dummy_precision())
+ // The following test is stable only if 2*angle != angle and v1 is not colinear with axis
+ if( (abs(aa.angle()) > test_precision<Scalar>()) && (abs(aa.axis().dot(v1.normalized()))<(Scalar(1)-Scalar(4)*test_precision<Scalar>())) )
{
VERIFY( !(q1 * v1).isApprox(Quaternionx(AngleAxisx(aa.angle()*2,aa.axis())) * v1) );
}
aa.fromRotationMatrix(aa.toRotationMatrix());
VERIFY_IS_APPROX(q1 * v1, Quaternionx(aa) * v1);
- if(abs(aa.angle()) > NumTraits<Scalar>::dummy_precision())
+ // The following test is stable only if 2*angle != angle and v1 is not colinear with axis
+ if( (abs(aa.angle()) > test_precision<Scalar>()) && (abs(aa.axis().dot(v1.normalized()))<(Scalar(1)-Scalar(4)*test_precision<Scalar>())) )
{
VERIFY( !(q1 * v1).isApprox(Quaternionx(AngleAxisx(aa.angle()*2,aa.axis())) * v1) );
}
@@ -158,7 +169,7 @@ template<typename Scalar, int Mode, int Options> void transformations()
// TODO complete the tests !
a = 0;
while (abs(a)<Scalar(0.1))
- a = internal::random<Scalar>(-Scalar(0.4)*Scalar(M_PI), Scalar(0.4)*Scalar(M_PI));
+ a = internal::random<Scalar>(-Scalar(0.4)*Scalar(EIGEN_PI), Scalar(0.4)*Scalar(EIGEN_PI));
q1 = AngleAxisx(a, v0.normalized());
Transform3 t0, t1, t2;
@@ -204,7 +215,7 @@ template<typename Scalar, int Mode, int Options> void transformations()
tmat4.matrix()(3,3) = Scalar(1);
VERIFY_IS_APPROX(tmat3.matrix(), tmat4.matrix());
- Scalar a3 = internal::random<Scalar>(-Scalar(M_PI), Scalar(M_PI));
+ Scalar a3 = internal::random<Scalar>(-Scalar(EIGEN_PI), Scalar(EIGEN_PI));
Vector3 v3 = Vector3::Random().normalized();
AngleAxisx aa3(a3, v3);
Transform3 t3(aa3);
@@ -216,12 +227,15 @@ template<typename Scalar, int Mode, int Options> void transformations()
t4 *= aa3;
VERIFY_IS_APPROX(t3.matrix(), t4.matrix());
- v3 = Vector3::Random();
+ do {
+ v3 = Vector3::Random();
+ dont_over_optimize(v3);
+ } while (v3.cwiseAbs().minCoeff()<NumTraits<Scalar>::epsilon());
Translation3 tv3(v3);
Transform3 t5(tv3);
t4 = tv3;
VERIFY_IS_APPROX(t5.matrix(), t4.matrix());
- t4.translate(-v3);
+ t4.translate((-v3).eval());
VERIFY_IS_APPROX(t4.matrix(), MatrixType::Identity());
t4 *= tv3;
VERIFY_IS_APPROX(t5.matrix(), t4.matrix());
@@ -413,12 +427,28 @@ template<typename Scalar, int Mode, int Options> void transformations()
VERIFY_IS_APPROX(r2d1f.template cast<Scalar>(),r2d1);
Rotation2D<double> r2d1d = r2d1.template cast<double>();
VERIFY_IS_APPROX(r2d1d.template cast<Scalar>(),r2d1);
-
- t20 = Translation2(v20) * (Rotation2D<Scalar>(s0) * Eigen::Scaling(s0));
- t21 = Translation2(v20) * Rotation2D<Scalar>(s0) * Eigen::Scaling(s0);
- VERIFY_IS_APPROX(t20,t21);
+ for(int k=0; k<100; ++k)
+ {
+ Scalar angle = internal::random<Scalar>(-100,100);
+ Rotation2D<Scalar> rot2(angle);
+ VERIFY( rot2.smallestPositiveAngle() >= 0 );
+ VERIFY( rot2.smallestPositiveAngle() <= Scalar(2)*Scalar(EIGEN_PI) );
+ VERIFY_IS_APPROX( angleToVec(rot2.smallestPositiveAngle()), angleToVec(rot2.angle()) );
+
+ VERIFY( rot2.smallestAngle() >= -Scalar(EIGEN_PI) );
+ VERIFY( rot2.smallestAngle() <= Scalar(EIGEN_PI) );
+ VERIFY_IS_APPROX( angleToVec(rot2.smallestAngle()), angleToVec(rot2.angle()) );
+
+ Matrix<Scalar,2,2> rot2_as_mat(rot2);
+ Rotation2D<Scalar> rot3(rot2_as_mat);
+ VERIFY_IS_APPROX( angleToVec(rot2.smallestAngle()), angleToVec(rot3.angle()) );
+ }
+
+ s0 = internal::random<Scalar>(-100,100);
+ s1 = internal::random<Scalar>(-100,100);
Rotation2D<Scalar> R0(s0), R1(s1);
+
t20 = Translation2(v20) * (R0 * Eigen::Scaling(s0));
t21 = Translation2(v20) * R0 * Eigen::Scaling(s0);
VERIFY_IS_APPROX(t20,t21);
@@ -428,9 +458,24 @@ template<typename Scalar, int Mode, int Options> void transformations()
VERIFY_IS_APPROX(t20,t21);
VERIFY_IS_APPROX(s0, (R0.slerp(0, R1)).angle());
- VERIFY_IS_APPROX(s1, (R0.slerp(1, R1)).angle());
- VERIFY_IS_APPROX(s0, (R0.slerp(0.5, R0)).angle());
- VERIFY_IS_APPROX(Scalar(0), (R0.slerp(0.5, R0.inverse())).angle());
+ VERIFY_IS_APPROX( angleToVec(R1.smallestPositiveAngle()), angleToVec((R0.slerp(1, R1)).smallestPositiveAngle()) );
+ VERIFY_IS_APPROX(R0.smallestPositiveAngle(), (R0.slerp(0.5, R0)).smallestPositiveAngle());
+
+ if(std::cos(s0)>0)
+ VERIFY_IS_MUCH_SMALLER_THAN((R0.slerp(0.5, R0.inverse())).smallestAngle(), Scalar(1));
+ else
+ VERIFY_IS_APPROX(Scalar(EIGEN_PI), (R0.slerp(0.5, R0.inverse())).smallestPositiveAngle());
+
+ // Check path length
+ Scalar l = 0;
+ int path_steps = 100;
+ for(int k=0; k<path_steps; ++k)
+ {
+ Scalar a1 = R0.slerp(Scalar(k)/Scalar(path_steps), R1).angle();
+ Scalar a2 = R0.slerp(Scalar(k+1)/Scalar(path_steps), R1).angle();
+ l += std::abs(a2-a1);
+ }
+ VERIFY(l<=Scalar(EIGEN_PI)*(Scalar(1)+NumTraits<Scalar>::epsilon()*Scalar(path_steps/2)));
// check basic features
{
@@ -520,9 +565,9 @@ template<typename Scalar> void transform_alignment()
typedef Transform<Scalar,3,Projective,AutoAlign> Projective3a;
typedef Transform<Scalar,3,Projective,DontAlign> Projective3u;
- EIGEN_ALIGN16 Scalar array1[16];
- EIGEN_ALIGN16 Scalar array2[16];
- EIGEN_ALIGN16 Scalar array3[16+1];
+ EIGEN_ALIGN_MAX Scalar array1[16];
+ EIGEN_ALIGN_MAX Scalar array2[16];
+ EIGEN_ALIGN_MAX Scalar array3[16+1];
Scalar* array3u = array3+1;
Projective3a *p1 = ::new(reinterpret_cast<void*>(array1)) Projective3a;
@@ -538,7 +583,7 @@ template<typename Scalar> void transform_alignment()
VERIFY_IS_APPROX( (*p1) * (*p1), (*p2)*(*p3));
- #if defined(EIGEN_VECTORIZE) && EIGEN_ALIGN_STATICALLY
+ #if defined(EIGEN_VECTORIZE) && EIGEN_MAX_STATIC_ALIGN_BYTES>0
if(internal::packet_traits<Scalar>::Vectorizable)
VERIFY_RAISES_ASSERT((::new(reinterpret_cast<void*>(array3u)) Projective3a));
#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-21 12:14:34 +0000