diff options
-rw-r--r-- | Eigen/src/Core/VectorwiseOp.h | 2 | ||||
-rw-r--r-- | Eigen/src/Core/products/CoeffBasedProduct.h | 2 | ||||
-rw-r--r-- | Eigen/src/Core/util/Macros.h | 2 | ||||
-rw-r--r-- | Eigen/src/Geometry/RotationBase.h | 24 | ||||
-rw-r--r-- | Eigen/src/Geometry/Transform.h | 215 | ||||
-rw-r--r-- | test/geo_transformations.cpp | 120 | ||||
-rw-r--r-- | test/main.h | 4 |
7 files changed, 190 insertions, 179 deletions
diff --git a/Eigen/src/Core/VectorwiseOp.h b/Eigen/src/Core/VectorwiseOp.h index 1867961f5..c9cb8e820 100644 --- a/Eigen/src/Core/VectorwiseOp.h +++ b/Eigen/src/Core/VectorwiseOp.h @@ -440,7 +440,7 @@ template<typename ExpressionType, int Direction> class VectorwiseOp } /** Returns the expression of the sum of the vector \a other to each subvector of \c *this */ - template<typename OtherDerived> + template<typename OtherDerived> EIGEN_STRONG_INLINE CwiseBinaryOp<ei_scalar_sum_op<Scalar>, ExpressionType, typename ExtendedType<OtherDerived>::Type> diff --git a/Eigen/src/Core/products/CoeffBasedProduct.h b/Eigen/src/Core/products/CoeffBasedProduct.h index c79a34de0..d2e693861 100644 --- a/Eigen/src/Core/products/CoeffBasedProduct.h +++ b/Eigen/src/Core/products/CoeffBasedProduct.h @@ -199,7 +199,7 @@ class CoeffBasedProduct } // Implicit conversion to the nested type (trigger the evaluation of the product) - operator const PlainObject& () const + EIGEN_STRONG_INLINE operator const PlainObject& () const { m_result.lazyAssign(*this); return m_result; diff --git a/Eigen/src/Core/util/Macros.h b/Eigen/src/Core/util/Macros.h index 2da9ab291..319c6c5fc 100644 --- a/Eigen/src/Core/util/Macros.h +++ b/Eigen/src/Core/util/Macros.h @@ -362,7 +362,7 @@ #define EIGEN_MAKE_CWISE_BINARY_OP(METHOD,FUNCTOR) \ template<typename OtherDerived> \ - inline const CwiseBinaryOp<FUNCTOR<Scalar>, Derived, OtherDerived> \ + EIGEN_STRONG_INLINE const CwiseBinaryOp<FUNCTOR<Scalar>, Derived, OtherDerived> \ METHOD(const EIGEN_CURRENT_STORAGE_BASE_CLASS<OtherDerived> &other) const \ { \ return CwiseBinaryOp<FUNCTOR<Scalar>, Derived, OtherDerived>(derived(), other.derived()); \ diff --git a/Eigen/src/Geometry/RotationBase.h b/Eigen/src/Geometry/RotationBase.h index 36f17584f..181e65be9 100644 --- a/Eigen/src/Geometry/RotationBase.h +++ b/Eigen/src/Geometry/RotationBase.h @@ -56,8 +56,8 @@ class RotationBase inline RotationMatrixType toRotationMatrix() const { return derived().toRotationMatrix(); } /** \returns an equivalent rotation matrix - * This function is added to be conform with the Transform class' naming scheme. - */ + * This function is added to be conform with the Transform class' naming scheme. + */ inline RotationMatrixType matrix() const { return derived().toRotationMatrix(); } /** \returns the inverse rotation */ @@ -87,6 +87,14 @@ class RotationBase inline RotationMatrixType operator*(const EigenBase<OtherDerived>& l, const Derived& r) { return l.derived() * r.toRotationMatrix(); } + /** \returns the concatenation of a scaling \a l with the rotation \a r */ + friend inline Transform<Scalar,Dim,Affine> operator*(const DiagonalMatrix<Scalar,Dim>& l, const Derived& r) + { + Transform<Scalar,Dim,Affine> res(r); + res.linear().applyOnTheLeft(l); + return res; + } + /** \returns the concatenation of the rotation \c *this with a transformation \a t */ template<int Mode> inline Transform<Scalar,Dim,Mode> operator*(const Transform<Scalar,Dim,Mode>& t) const @@ -107,6 +115,18 @@ struct ei_rotation_base_generic_product_selector<RotationDerived,MatrixType,fals { return r.toRotationMatrix() * m; } }; +template<typename RotationDerived, typename Scalar, int Dim, int MaxDim> +struct ei_rotation_base_generic_product_selector< RotationDerived, DiagonalMatrix<Scalar,Dim,MaxDim>, false > +{ + typedef Transform<Scalar,Dim,Affine> ReturnType; + inline static ReturnType run(const RotationDerived& r, const DiagonalMatrix<Scalar,Dim,MaxDim>& m) + { + ReturnType res(r); + res.linear() *= m; + return res; + } +}; + template<typename RotationDerived,typename OtherVectorType> struct ei_rotation_base_generic_product_selector<RotationDerived,OtherVectorType,true> { diff --git a/Eigen/src/Geometry/Transform.h b/Eigen/src/Geometry/Transform.h index 702e87663..bf55fd171 100644 --- a/Eigen/src/Geometry/Transform.h +++ b/Eigen/src/Geometry/Transform.h @@ -42,7 +42,8 @@ template< typename Other, int Dim, int HDim, int OtherRows=Other::RowsAtCompileTime, - int OtherCols=Other::ColsAtCompileTime> + int OtherCols=Other::ColsAtCompileTime, + bool IsProjective = (Mode==(int)Projective)> struct ei_transform_right_product_impl; template<typename TransformType> struct ei_transform_take_affine_part; @@ -55,9 +56,9 @@ template< typename Other, int OtherCols=Other::ColsAtCompileTime> struct ei_transform_left_product_impl; -template<typename Lhs, - typename Rhs, - bool AnyProjective = ei_is_any_projective<Lhs,Rhs>::value > +template< typename Lhs, + typename Rhs, + bool AnyProjective = ei_is_any_projective<Lhs,Rhs>::value > struct ei_transform_transform_product_impl; template< typename Other, @@ -353,8 +354,8 @@ public: */ // note: this function is defined here because some compilers cannot find the respective declaration template<typename OtherDerived> - inline const typename ei_transform_right_product_impl<OtherDerived,Mode,_Dim,_Dim+1>::ResultType - operator * (const EigenBase<OtherDerived> &other) const + EIGEN_STRONG_INLINE const typename ei_transform_right_product_impl<OtherDerived,Mode,_Dim,_Dim+1>::ResultType + operator * (const EigenBase<OtherDerived> &other) const { return ei_transform_right_product_impl<OtherDerived,Mode,Dim,HDim>::run(*this,other.derived()); } /** \returns the product expression of a transformation matrix \a a times a transform \a b @@ -366,9 +367,40 @@ public: */ template<typename OtherDerived> friend inline const typename ei_transform_left_product_impl<OtherDerived,Mode,_Dim,_Dim+1>::ResultType - operator * (const EigenBase<OtherDerived> &a, const Transform &b) + operator * (const EigenBase<OtherDerived> &a, const Transform &b) { return ei_transform_left_product_impl<OtherDerived,Mode,Dim,HDim>::run(a.derived(),b); } + /** \returns The product expression of a transform \a a times a diagonal matrix \a b + * + * The rhs diagonal matrix is interpreted as an affine scaling transformation. The + * product results in a Transform of the same type (mode) as the lhs only if the lhs + * mode is no isometry. In that case, the returned transform is an affinity. + */ + friend inline const Transform<Scalar,Dim,((Mode==(int)Isometry)?Affine:(int)Mode)> + operator * (const Transform &a, const DiagonalMatrix<Scalar,Dim> &b) + { + Transform<Scalar,Dim,((Mode==(int)Isometry)?Affine:(int)Mode)> res(a); + res.linear() *= b; + return res; + } + + /** \returns The product expression of a diagonal matrix \a a times a transform \a b + * + * The lhs diagonal matrix is interpreted as an affine scaling transformation. The + * product results in a Transform of the same type (mode) as the lhs only if the lhs + * mode is no isometry. In that case, the returned transform is an affinity. + */ + friend inline const Transform<Scalar,Dim,((Mode==(int)Isometry)?Affine:(int)Mode)> + operator * (const DiagonalMatrix<Scalar,Dim> &a, const Transform &b) + { + Transform<Scalar,Dim,((Mode==(int)Isometry)?Affine:(int)Mode)> res; + res.linear().noalias() = a*b.linear(); + res.translation().noalias() = a*b.translation(); + if (Mode!=int(AffineCompact)) + res.matrix().row(Dim) = b.matrix().row(Dim); + return res; + } + template<typename OtherDerived> inline Transform& operator*=(const EigenBase<OtherDerived>& other) { return *this = *this * other; } @@ -381,8 +413,8 @@ public: /** Concatenates two different transformations */ template<int OtherMode> inline const typename ei_transform_transform_product_impl< - Transform,Transform<Scalar,Dim,OtherMode> >::ResultType - operator * (const Transform<Scalar,Dim,OtherMode>& other) const + Transform,Transform<Scalar,Dim,OtherMode> >::ResultType + operator * (const Transform<Scalar,Dim,OtherMode>& other) const { return ei_transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode> >::run(*this,other); } @@ -431,6 +463,8 @@ public: inline Transform& operator*=(const UniformScaling<Scalar>& s) { return scale(s.factor()); } inline Transform operator*(const UniformScaling<Scalar>& s) const; + inline Transform& operator*=(const DiagonalMatrix<Scalar,Dim>& s) { linear() *= s; return *this; } + template<typename Derived> inline Transform& operator=(const RotationBase<Derived,Dim>& r); template<typename Derived> @@ -582,7 +616,7 @@ Transform<Scalar,Dim,Mode>& Transform<Scalar,Dim,Mode>::operator=(const QMatrix& m_matrix << other.m11(), other.m21(), other.dx(), other.m12(), other.m22(), other.dy(), 0, 0, 1; - return *this; + return *this; } /** \returns a QMatrix from \c *this assuming the dimension is 2. @@ -621,7 +655,7 @@ Transform<Scalar,Dim,Mode>& Transform<Scalar,Dim,Mode>::operator=(const QTransfo m_matrix << other.m11(), other.m21(), other.dx(), other.m12(), other.m22(), other.dy(), other.m13(), other.m23(), other.m33(); - return *this; + return *this; } /** \returns a QTransform from \c *this assuming the dimension is 2. @@ -1058,15 +1092,15 @@ struct ei_transform_construct_from_matrix<Other, AffineCompact,Dim,HDim, HDim,HD { transform->matrix() = other.template block<Dim,HDim>(0,0); } }; -/********************************************************* -*** Specializations of operator* with a EigenBase *** -*********************************************************/ +/********************************************************** +*** Specializations of operator* with rhs EigenBase *** +**********************************************************/ // ei_general_product_return_type is a generalization of ProductReturnType, for all types (including e.g. DiagonalBase...), // instead of being restricted to MatrixBase. template<typename Lhs, typename Rhs> struct ei_general_product_return_type; template<typename D1, typename D2> struct ei_general_product_return_type<MatrixBase<D1>, MatrixBase<D2> > - : ProductReturnType<D1,D2> {}; + : ProductReturnType<D1,D2> {}; template<typename Lhs, typename D2> struct ei_general_product_return_type<Lhs, MatrixBase<D2> > { typedef D2 Type; }; template<typename D1, typename Rhs> struct ei_general_product_return_type<MatrixBase<D1>, Rhs > @@ -1085,145 +1119,48 @@ struct ei_transform_product_result }; }; -// Projective * set of homogeneous column vectors -template<typename Other, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Projective, Dim,HDim, HDim, Dynamic> -{ - typedef Transform<typename Other::Scalar,Dim,Projective> TransformType; - typedef typename TransformType::MatrixType MatrixType; - typedef typename ProductReturnType<MatrixType,Other>::Type ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { return tr.matrix() * other; } -}; - -// Projective * homogeneous column vector -template<typename Other, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Projective, Dim,HDim, HDim, 1> +template< typename Other, int Mode, int Dim, int HDim, int OtherCols > +struct ei_transform_right_product_impl<Other, Mode, Dim, HDim, HDim, OtherCols, true> { - typedef Transform<typename Other::Scalar,Dim,Projective> TransformType; - typedef typename TransformType::MatrixType MatrixType; - typedef typename ProductReturnType<MatrixType,Other>::Type ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { return tr.matrix() * other; } -}; + typedef typename Other::Scalar Scalar; + typedef typename Other::PlainObject ResultType; -// Projective * column vector -template<typename Other, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Projective, Dim,HDim, Dim, 1> -{ - typedef Transform<typename Other::Scalar,Dim,Projective> TransformType; - typedef Matrix<typename Other::Scalar,HDim,1> ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { return tr.matrix().template block<HDim,Dim>(0,0) * other + tr.matrix().col(Dim); } -}; - -// Affine * column vector -template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Mode, Dim,HDim, Dim,1> -{ - typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; - typedef Matrix<typename Other::Scalar,Dim,1> ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { return tr.linear() * other + tr.translation(); } -}; - -// Affine * set of column vectors -// FIXME use a ReturnByValue to remove the temporary -template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Mode, Dim,HDim, Dim,Dynamic> -{ - typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; - typedef Matrix<typename Other::Scalar,Dim,Dynamic> ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { return (tr.linear() * other).colwise() + tr.translation(); } -}; - -// Affine * homogeneous column vector -// FIXME added for backward compatibility, but I'm not sure we should keep it -template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Mode, Dim,HDim, HDim,1> -{ - typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; - typedef Matrix<typename Other::Scalar,HDim,1> ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { return tr.matrix() * other; } -}; -template<typename Other, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,AffineCompact, Dim,HDim, HDim,1> -{ - typedef Transform<typename Other::Scalar,Dim,AffineCompact> TransformType; - typedef Matrix<typename Other::Scalar,HDim,1> ResultType; - static ResultType run(const TransformType& tr, const Other& other) + EIGEN_STRONG_INLINE static ResultType run(const Transform<Scalar,Dim,Projective>& T, const Other& other) { - ResultType res; - res.template head<HDim>() = tr.matrix() * other; - res.coeffRef(Dim) = other.coeff(Dim); + return T.matrix() * other; } }; -// T * linear matrix => T -template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Mode, Dim,HDim, Dim,Dim> +template< typename Other, int Mode, int Dim, int HDim, int OtherRows, int OtherCols > +struct ei_transform_right_product_impl<Other, Mode, Dim, HDim, OtherRows, OtherCols, false> { - typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; - typedef typename TransformType::MatrixType MatrixType; - typedef TransformType ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { - TransformType res; - res.matrix().col(Dim) = tr.matrix().col(Dim); - res.linearExt().noalias() = (tr.linearExt() * other); - if(Mode==int(Affine)) - res.matrix().row(Dim).template head<Dim>() = tr.matrix().row(Dim).template head<Dim>(); - return res; - } -}; + typedef typename Other::Scalar Scalar; + typedef typename Other::PlainObject ResultType; -// T * affine matrix => T -template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Mode, Dim,HDim, Dim,HDim> -{ - typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; - typedef typename TransformType::MatrixType MatrixType; - typedef TransformType ResultType; - static ResultType run(const TransformType& tr, const Other& other) + EIGEN_STRONG_INLINE static ResultType run(const Transform<Scalar,Dim,Mode>& T, const Other& other) { - TransformType res; - enum { Rows = Mode==int(Projective) ? HDim : Dim }; - res.matrix().template block<Rows,HDim>(0,0).noalias() = (tr.linearExt() * other); - res.translationExt() += tr.translationExt(); - if(Mode!=int(Affine)) - res.makeAffine(); - return res; - } -}; + EIGEN_STATIC_ASSERT(OtherRows==Dim || OtherRows==HDim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES); -// T * generic matrix => Projective -template<typename Other, int Mode, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,Mode, Dim,HDim, HDim,HDim> -{ - typedef Transform<typename Other::Scalar,Dim,Mode> TransformType; - typedef typename TransformType::MatrixType MatrixType; - typedef Transform<typename Other::Scalar,Dim,Projective> ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { return ResultType(tr.matrix() * other); } -}; + typedef Block<ResultType, Dim, OtherCols> TopLeftLhs; + typedef Block<Other, Dim, OtherCols> TopLeftRhs; + + ResultType res(other.rows(),other.cols()); + + TopLeftLhs(res, 0, 0, Dim, other.cols()) = + ( T.linear() * TopLeftRhs(other, 0, 0, Dim, other.cols()) ).colwise() + + T.translation(); + + // we need to take .rows() because OtherRows might be Dim or HDim + if (OtherRows==HDim) + res.row(other.rows()) = other.row(other.rows()); -// AffineCompact * generic matrix => Projective -template<typename Other, int Dim, int HDim> -struct ei_transform_right_product_impl<Other,AffineCompact, Dim,HDim, HDim,HDim> -{ - typedef Transform<typename Other::Scalar,Dim,AffineCompact> TransformType; - typedef Transform<typename Other::Scalar,Dim,Projective> ResultType; - static ResultType run(const TransformType& tr, const Other& other) - { - ResultType res; - res.affine().noalias() = tr.matrix() * other; - res.makeAffine(); return res; } }; +/********************************************************** +*** Specializations of operator* with lhs EigenBase *** +**********************************************************/ // generic HDim x HDim matrix * T => Projective template<typename Other,int Mode, int Dim, int HDim> diff --git a/test/geo_transformations.cpp b/test/geo_transformations.cpp index d932677b5..b9ea6bb91 100644 --- a/test/geo_transformations.cpp +++ b/test/geo_transformations.cpp @@ -27,6 +27,81 @@ #include <Eigen/LU> #include <Eigen/SVD> +template<typename Scalar, int Mode> void non_projective_only(void) +{ + /* this test covers the following files: + Cross.h Quaternion.h, Transform.cpp + */ + typedef Matrix<Scalar,2,2> Matrix2; + typedef Matrix<Scalar,3,3> Matrix3; + typedef Matrix<Scalar,4,4> Matrix4; + typedef Matrix<Scalar,2,1> Vector2; + typedef Matrix<Scalar,3,1> Vector3; + typedef Matrix<Scalar,4,1> Vector4; + typedef Quaternion<Scalar> Quaternionx; + typedef AngleAxis<Scalar> AngleAxisx; + typedef Transform<Scalar,2,Mode> Transform2; + typedef Transform<Scalar,3,Mode> Transform3; + typedef Transform<Scalar,2,Isometry> Isometry2; + typedef Transform<Scalar,3,Isometry> Isometry3; + typedef typename Transform3::MatrixType MatrixType; + typedef DiagonalMatrix<Scalar,2> AlignedScaling2; + typedef DiagonalMatrix<Scalar,3> AlignedScaling3; + typedef Translation<Scalar,2> Translation2; + typedef Translation<Scalar,3> Translation3; + + Scalar largeEps = test_precision<Scalar>(); + if (ei_is_same_type<Scalar,float>::ret) + largeEps = 1e-2f; + + Vector3 v0 = Vector3::Random(), + v1 = Vector3::Random(); + + Transform3 t0, t1, t2; + + Scalar a = ei_random<Scalar>(-Scalar(M_PI), Scalar(M_PI)); + + Quaternionx q1, q2; + + q1 = AngleAxisx(a, v0.normalized()); + + t0 = Transform3::Identity(); + VERIFY_IS_APPROX(t0.matrix(), Transform3::MatrixType::Identity()); + + t0.linear() = q1.toRotationMatrix(); + + v0 << 50, 2, 1; + t0.scale(v0); + + VERIFY_IS_APPROX( (t0 * Vector3(1,0,0)).template head<3>().norm(), v0.x()); + + t0.setIdentity(); + t1.setIdentity(); + v1 << 1, 2, 3; + t0.linear() = q1.toRotationMatrix(); + t0.pretranslate(v0); + t0.scale(v1); + t1.linear() = q1.conjugate().toRotationMatrix(); + t1.prescale(v1.cwiseInverse()); + t1.translate(-v0); + + VERIFY((t0 * t1).matrix().isIdentity(test_precision<Scalar>())); + + t1.fromPositionOrientationScale(v0, q1, v1); + VERIFY_IS_APPROX(t1.matrix(), t0.matrix()); + VERIFY_IS_APPROX(t1*v1, t0*v1); + + // translation * vector + t0.setIdentity(); + t0.translate(v0); + VERIFY_IS_APPROX((t0 * v1).template head<3>(), Translation3(v0) * v1); + + // AlignedScaling * vector + t0.setIdentity(); + t0.scale(v0); + VERIFY_IS_APPROX((t0 * v1).template head<3>(), AlignedScaling3(v0) * v1); +} + template<typename Scalar, int Mode> void transformations(void) { /* this test covers the following files: @@ -42,6 +117,8 @@ template<typename Scalar, int Mode> void transformations(void) typedef AngleAxis<Scalar> AngleAxisx; typedef Transform<Scalar,2,Mode> Transform2; typedef Transform<Scalar,3,Mode> Transform3; + typedef Transform<Scalar,2,Isometry> Isometry2; + typedef Transform<Scalar,3,Isometry> Isometry3; typedef typename Transform3::MatrixType MatrixType; typedef DiagonalMatrix<Scalar,2> AlignedScaling2; typedef DiagonalMatrix<Scalar,3> AlignedScaling3; @@ -115,17 +192,6 @@ template<typename Scalar, int Mode> void transformations(void) t0 = Transform3::Identity(); VERIFY_IS_APPROX(t0.matrix(), Transform3::MatrixType::Identity()); - t0.linear() = q1.toRotationMatrix(); - t1.setIdentity(); - t1.linear() = q1.toRotationMatrix(); - - v0 << 50, 2, 1;//= ei_random_matrix<Vector3>().cwiseProduct(Vector3(10,2,0.5)); - t0.scale(v0); - t1.prescale(v0); - - VERIFY_IS_APPROX( (t0 * Vector3(1,0,0)).template head<3>().norm(), v0.x()); - //VERIFY(!ei_isApprox((t1 * Vector3(1,0,0)).norm(), v0.x())); - t0.setIdentity(); t1.setIdentity(); v1 << 1, 2, 3; @@ -140,7 +206,6 @@ template<typename Scalar, int Mode> void transformations(void) t1.fromPositionOrientationScale(v0, q1, v1); VERIFY_IS_APPROX(t1.matrix(), t0.matrix()); - VERIFY_IS_APPROX(t1*v1, t0*v1); t0.setIdentity(); t0.scale(v0).rotate(q1.toRotationMatrix()); t1.setIdentity(); t1.scale(v0).rotate(q1); @@ -248,20 +313,20 @@ template<typename Scalar, int Mode> void transformations(void) t0.setIdentity(); t0.prerotate(q1).prescale(v0).pretranslate(v0); // translation * aligned scaling and transformation * mat - t1 = (Translation3(v0) * AlignedScaling3(v0)) * Matrix3(q1); + t1 = (Translation3(v0) * AlignedScaling3(v0)) * Transform3(q1); VERIFY_IS_APPROX(t0.matrix(), t1.matrix()); // scaling * mat and translation * mat - t1 = Translation3(v0) * (AlignedScaling3(v0) * Matrix3(q1)); + t1 = Translation3(v0) * (AlignedScaling3(v0) * Transform3(q1)); VERIFY_IS_APPROX(t0.matrix(), t1.matrix()); t0.setIdentity(); t0.scale(v0).translate(v0).rotate(q1); // translation * mat and aligned scaling * transformation - t1 = AlignedScaling3(v0) * (Translation3(v0) * Matrix3(q1)); + t1 = AlignedScaling3(v0) * (Translation3(v0) * Transform3(q1)); VERIFY_IS_APPROX(t0.matrix(), t1.matrix()); // transformation * aligned scaling t0.scale(v0); - t1 = t1 * AlignedScaling3(v0); + t1 *= AlignedScaling3(v0); VERIFY_IS_APPROX(t0.matrix(), t1.matrix()); // transformation * translation t0.translate(v0); @@ -302,16 +367,6 @@ template<typename Scalar, int Mode> void transformations(void) t1 = t1 * (q1 * AlignedScaling3(v1)); VERIFY_IS_APPROX(t0.matrix(), t1.matrix()); - // translation * vector - t0.setIdentity(); - t0.translate(v0); - VERIFY_IS_APPROX((t0 * v1).template head<3>(), Translation3(v0) * v1); - - // AlignedScaling * vector - t0.setIdentity(); - t0.scale(v0); - VERIFY_IS_APPROX((t0 * v1).template head<3>(), AlignedScaling3(v0) * v1); - // test transform inversion t0.setIdentity(); t0.translate(v0); @@ -327,11 +382,6 @@ template<typename Scalar, int Mode> void transformations(void) t044.block(0,0,t0.matrix().rows(),4) = t0.matrix(); VERIFY_IS_APPROX(t0.inverse(Isometry).matrix(), t044.inverse().block(0,0,t0.matrix().rows(),4)); - // test extract rotation and aligned scaling -// t0.setIdentity(); -// t0.translate(v0).rotate(q1).scale(v1); -// VERIFY_IS_APPROX(t0.rotation() * v1, Matrix3(q1) * v1); - Matrix3 mat_rotation, mat_scaling; t0.setIdentity(); t0.translate(v0).rotate(q1).scale(v1); @@ -372,8 +422,12 @@ template<typename Scalar, int Mode> void transformations(void) void test_geo_transformations() { for(int i = 0; i < g_repeat; i++) { - //CALL_SUBTEST_1(( transformations<double,Affine>() )); - //CALL_SUBTEST_2(( transformations<float,AffineCompact>() )); + CALL_SUBTEST_1(( transformations<double,Affine>() )); + CALL_SUBTEST_1(( non_projective_only<double,Affine>() )); + + CALL_SUBTEST_2(( transformations<float,AffineCompact>() )); + CALL_SUBTEST_2(( non_projective_only<float,AffineCompact>() )); + CALL_SUBTEST_3(( transformations<double,Projective>() )); } } diff --git a/test/main.h b/test/main.h index 6aee00373..8fa4ca8b5 100644 --- a/test/main.h +++ b/test/main.h @@ -118,7 +118,7 @@ namespace Eigen for (uint ai=0 ; ai<ei_assert_list.size() ; ++ai) \ std::cerr << " " << ei_assert_list[ai] << "\n"; \ VERIFY(Eigen::should_raise_an_assert && # a); \ - } catch (Eigen::ei_assert_exception e) { \ + } catch (Eigen::ei_assert_exception) { \ Eigen::ei_push_assert = false; VERIFY(true); \ } \ Eigen::report_on_cerr_on_assert_failure = true; \ @@ -144,7 +144,7 @@ namespace Eigen a; \ VERIFY(Eigen::should_raise_an_assert && # a); \ } \ - catch (Eigen::ei_assert_exception& e) { VERIFY(true); } \ + catch (Eigen::ei_assert_exception&) { VERIFY(true); } \ Eigen::report_on_cerr_on_assert_failure = true; \ } |