Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.0
 
Loading...
Searching...
No Matches
Transform.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
6// Copyright (C) 2010 Hauke Heibel <hauke.heibel@gmail.com>
7//
8// This Source Code Form is subject to the terms of the Mozilla
9// Public License v. 2.0. If a copy of the MPL was not distributed
10// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
11
12#ifndef EIGEN_TRANSFORM_H
13#define EIGEN_TRANSFORM_H
14
15namespace Eigen {
16
17namespace internal {
18
19template<typename Transform>
20struct transform_traits
21{
22 enum
23 {
24 Dim = Transform::Dim,
25 HDim = Transform::HDim,
26 Mode = Transform::Mode,
27 IsProjective = (int(Mode)==int(Projective))
28 };
29};
30
31template< typename TransformType,
32 typename MatrixType,
33 int Case = transform_traits<TransformType>::IsProjective ? 0
34 : int(MatrixType::RowsAtCompileTime) == int(transform_traits<TransformType>::HDim) ? 1
35 : 2,
36 int RhsCols = MatrixType::ColsAtCompileTime>
37struct transform_right_product_impl;
38
39template< typename Other,
40 int Mode,
41 int Options,
42 int Dim,
43 int HDim,
44 int OtherRows=Other::RowsAtCompileTime,
45 int OtherCols=Other::ColsAtCompileTime>
46struct transform_left_product_impl;
47
48template< typename Lhs,
49 typename Rhs,
50 bool AnyProjective =
51 transform_traits<Lhs>::IsProjective ||
52 transform_traits<Rhs>::IsProjective>
53struct transform_transform_product_impl;
54
55template< typename Other,
56 int Mode,
57 int Options,
58 int Dim,
59 int HDim,
60 int OtherRows=Other::RowsAtCompileTime,
61 int OtherCols=Other::ColsAtCompileTime>
62struct transform_construct_from_matrix;
63
64template<typename TransformType> struct transform_take_affine_part;
65
66template<typename _Scalar, int _Dim, int _Mode, int _Options>
67struct traits<Transform<_Scalar,_Dim,_Mode,_Options> >
68{
69 typedef _Scalar Scalar;
70 typedef Eigen::Index StorageIndex;
71 typedef Dense StorageKind;
72 enum {
73 Dim1 = _Dim==Dynamic ? _Dim : _Dim + 1,
74 RowsAtCompileTime = _Mode==Projective ? Dim1 : _Dim,
75 ColsAtCompileTime = Dim1,
76 MaxRowsAtCompileTime = RowsAtCompileTime,
77 MaxColsAtCompileTime = ColsAtCompileTime,
78 Flags = 0
79 };
80};
81
82template<int Mode> struct transform_make_affine;
83
84} // end namespace internal
85
203template<typename _Scalar, int _Dim, int _Mode, int _Options>
205{
206public:
208 enum {
209 Mode = _Mode,
210 Options = _Options,
211 Dim = _Dim,
212 HDim = _Dim+1,
213 Rows = int(Mode)==(AffineCompact) ? Dim : HDim
214 };
216 typedef _Scalar Scalar;
217 typedef Eigen::Index StorageIndex;
226 typedef Block<MatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (int(Options)&RowMajor)==0> LinearPart;
228 typedef const Block<ConstMatrixType,Dim,Dim,int(Mode)==(AffineCompact) && (int(Options)&RowMajor)==0> ConstLinearPart;
230 typedef typename internal::conditional<int(Mode)==int(AffineCompact),
231 MatrixType&,
234 typedef typename internal::conditional<int(Mode)==int(AffineCompact),
235 const MatrixType&,
240 typedef Block<MatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> TranslationPart;
242 typedef const Block<ConstMatrixType,Dim,1,!(internal::traits<MatrixType>::Flags & RowMajorBit)> ConstTranslationPart;
245
246 // this intermediate enum is needed to avoid an ICE with gcc 3.4 and 4.0
247 enum { TransformTimeDiagonalMode = ((Mode==int(Isometry))?Affine:int(Mode)) };
250
251protected:
252
253 MatrixType m_matrix;
254
255public:
256
259 EIGEN_DEVICE_FUNC inline Transform()
260 {
261 check_template_params();
262 internal::transform_make_affine<(int(Mode)==Affine || int(Mode)==Isometry) ? Affine : AffineCompact>::run(m_matrix);
263 }
264
265 EIGEN_DEVICE_FUNC inline explicit Transform(const TranslationType& t)
266 {
267 check_template_params();
268 *this = t;
269 }
270 EIGEN_DEVICE_FUNC inline explicit Transform(const UniformScaling<Scalar>& s)
271 {
272 check_template_params();
273 *this = s;
274 }
275 template<typename Derived>
276 EIGEN_DEVICE_FUNC inline explicit Transform(const RotationBase<Derived, Dim>& r)
277 {
278 check_template_params();
279 *this = r;
280 }
281
282 typedef internal::transform_take_affine_part<Transform> take_affine_part;
283
285 template<typename OtherDerived>
286 EIGEN_DEVICE_FUNC inline explicit Transform(const EigenBase<OtherDerived>& other)
287 {
288 EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
289 YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
290
291 check_template_params();
292 internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
293 }
294
296 template<typename OtherDerived>
297 EIGEN_DEVICE_FUNC inline Transform& operator=(const EigenBase<OtherDerived>& other)
298 {
299 EIGEN_STATIC_ASSERT((internal::is_same<Scalar,typename OtherDerived::Scalar>::value),
300 YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY);
301
302 internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
303 return *this;
304 }
305
306 template<int OtherOptions>
307 EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,Mode,OtherOptions>& other)
308 {
309 check_template_params();
310 // only the options change, we can directly copy the matrices
311 m_matrix = other.matrix();
312 }
313
314 template<int OtherMode,int OtherOptions>
315 EIGEN_DEVICE_FUNC inline Transform(const Transform<Scalar,Dim,OtherMode,OtherOptions>& other)
316 {
317 check_template_params();
318 // prevent conversions as:
319 // Affine | AffineCompact | Isometry = Projective
320 EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Projective), Mode==int(Projective)),
321 YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
322
323 // prevent conversions as:
324 // Isometry = Affine | AffineCompact
325 EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Affine)||OtherMode==int(AffineCompact), Mode!=int(Isometry)),
326 YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
327
328 enum { ModeIsAffineCompact = Mode == int(AffineCompact),
329 OtherModeIsAffineCompact = OtherMode == int(AffineCompact)
330 };
331
332 if(EIGEN_CONST_CONDITIONAL(ModeIsAffineCompact == OtherModeIsAffineCompact))
333 {
334 // We need the block expression because the code is compiled for all
335 // combinations of transformations and will trigger a compile time error
336 // if one tries to assign the matrices directly
337 m_matrix.template block<Dim,Dim+1>(0,0) = other.matrix().template block<Dim,Dim+1>(0,0);
338 makeAffine();
339 }
340 else if(EIGEN_CONST_CONDITIONAL(OtherModeIsAffineCompact))
341 {
342 typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixType OtherMatrixType;
343 internal::transform_construct_from_matrix<OtherMatrixType,Mode,Options,Dim,HDim>::run(this, other.matrix());
344 }
345 else
346 {
347 // here we know that Mode == AffineCompact and OtherMode != AffineCompact.
348 // if OtherMode were Projective, the static assert above would already have caught it.
349 // So the only possibility is that OtherMode == Affine
350 linear() = other.linear();
351 translation() = other.translation();
352 }
353 }
354
355 template<typename OtherDerived>
356 EIGEN_DEVICE_FUNC Transform(const ReturnByValue<OtherDerived>& other)
357 {
358 check_template_params();
359 other.evalTo(*this);
360 }
361
362 template<typename OtherDerived>
363 EIGEN_DEVICE_FUNC Transform& operator=(const ReturnByValue<OtherDerived>& other)
364 {
365 other.evalTo(*this);
366 return *this;
367 }
368
369 #ifdef EIGEN_QT_SUPPORT
370 inline Transform(const QMatrix& other);
371 inline Transform& operator=(const QMatrix& other);
372 inline QMatrix toQMatrix(void) const;
373 inline Transform(const QTransform& other);
374 inline Transform& operator=(const QTransform& other);
375 inline QTransform toQTransform(void) const;
376 #endif
377
378 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return int(Mode)==int(Projective) ? m_matrix.cols() : (m_matrix.cols()-1); }
379 EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_matrix.cols(); }
380
383 EIGEN_DEVICE_FUNC inline Scalar operator() (Index row, Index col) const { return m_matrix(row,col); }
386 EIGEN_DEVICE_FUNC inline Scalar& operator() (Index row, Index col) { return m_matrix(row,col); }
387
389 EIGEN_DEVICE_FUNC inline const MatrixType& matrix() const { return m_matrix; }
391 EIGEN_DEVICE_FUNC inline MatrixType& matrix() { return m_matrix; }
392
394 EIGEN_DEVICE_FUNC inline ConstLinearPart linear() const { return ConstLinearPart(m_matrix,0,0); }
396 EIGEN_DEVICE_FUNC inline LinearPart linear() { return LinearPart(m_matrix,0,0); }
397
399 EIGEN_DEVICE_FUNC inline ConstAffinePart affine() const { return take_affine_part::run(m_matrix); }
401 EIGEN_DEVICE_FUNC inline AffinePart affine() { return take_affine_part::run(m_matrix); }
402
404 EIGEN_DEVICE_FUNC inline ConstTranslationPart translation() const { return ConstTranslationPart(m_matrix,0,Dim); }
406 EIGEN_DEVICE_FUNC inline TranslationPart translation() { return TranslationPart(m_matrix,0,Dim); }
407
432 // note: this function is defined here because some compilers cannot find the respective declaration
433 template<typename OtherDerived>
434 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl<Transform, OtherDerived>::ResultType
436 { return internal::transform_right_product_impl<Transform, OtherDerived>::run(*this,other.derived()); }
437
445 template<typename OtherDerived> friend
446 EIGEN_DEVICE_FUNC inline const typename internal::transform_left_product_impl<OtherDerived,Mode,Options,_Dim,_Dim+1>::ResultType
448 { return internal::transform_left_product_impl<OtherDerived,Mode,Options,Dim,HDim>::run(a.derived(),b); }
449
456 template<typename DiagonalDerived>
457 EIGEN_DEVICE_FUNC inline const TransformTimeDiagonalReturnType
458 operator * (const DiagonalBase<DiagonalDerived> &b) const
459 {
461 res.linearExt() *= b;
462 return res;
463 }
464
471 template<typename DiagonalDerived>
472 EIGEN_DEVICE_FUNC friend inline TransformTimeDiagonalReturnType
473 operator * (const DiagonalBase<DiagonalDerived> &a, const Transform &b)
474 {
476 res.linear().noalias() = a*b.linear();
477 res.translation().noalias() = a*b.translation();
478 if (EIGEN_CONST_CONDITIONAL(Mode!=int(AffineCompact)))
479 res.matrix().row(Dim) = b.matrix().row(Dim);
480 return res;
481 }
482
483 template<typename OtherDerived>
484 EIGEN_DEVICE_FUNC inline Transform& operator*=(const EigenBase<OtherDerived>& other) { return *this = *this * other; }
485
487 EIGEN_DEVICE_FUNC inline const Transform operator * (const Transform& other) const
488 {
489 return internal::transform_transform_product_impl<Transform,Transform>::run(*this,other);
490 }
491
492 #if EIGEN_COMP_ICC
493private:
494 // this intermediate structure permits to workaround a bug in ICC 11:
495 // error: template instantiation resulted in unexpected function type of "Eigen::Transform<double, 3, 32, 0>
496 // (const Eigen::Transform<double, 3, 2, 0> &) const"
497 // (the meaning of a name may have changed since the template declaration -- the type of the template is:
498 // "Eigen::internal::transform_transform_product_impl<Eigen::Transform<double, 3, 32, 0>,
499 // Eigen::Transform<double, 3, Mode, Options>, <expression>>::ResultType (const Eigen::Transform<double, 3, Mode, Options> &) const")
500 //
501 template<int OtherMode,int OtherOptions> struct icc_11_workaround
502 {
503 typedef internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> > ProductType;
504 typedef typename ProductType::ResultType ResultType;
505 };
506
507public:
509 template<int OtherMode,int OtherOptions>
510 inline typename icc_11_workaround<OtherMode,OtherOptions>::ResultType
511 operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
512 {
513 typedef typename icc_11_workaround<OtherMode,OtherOptions>::ProductType ProductType;
514 return ProductType::run(*this,other);
515 }
516 #else
518 template<int OtherMode,int OtherOptions>
519 EIGEN_DEVICE_FUNC inline typename internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::ResultType
521 {
522 return internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::run(*this,other);
523 }
524 #endif
525
527 EIGEN_DEVICE_FUNC void setIdentity() { m_matrix.setIdentity(); }
528
533 EIGEN_DEVICE_FUNC static const Transform Identity()
534 {
535 return Transform(MatrixType::Identity());
536 }
537
538 template<typename OtherDerived>
539 EIGEN_DEVICE_FUNC
540 inline Transform& scale(const MatrixBase<OtherDerived> &other);
541
542 template<typename OtherDerived>
543 EIGEN_DEVICE_FUNC
544 inline Transform& prescale(const MatrixBase<OtherDerived> &other);
545
546 EIGEN_DEVICE_FUNC inline Transform& scale(const Scalar& s);
547 EIGEN_DEVICE_FUNC inline Transform& prescale(const Scalar& s);
548
549 template<typename OtherDerived>
550 EIGEN_DEVICE_FUNC
551 inline Transform& translate(const MatrixBase<OtherDerived> &other);
552
553 template<typename OtherDerived>
554 EIGEN_DEVICE_FUNC
555 inline Transform& pretranslate(const MatrixBase<OtherDerived> &other);
556
557 template<typename RotationType>
558 EIGEN_DEVICE_FUNC
559 inline Transform& rotate(const RotationType& rotation);
560
561 template<typename RotationType>
562 EIGEN_DEVICE_FUNC
563 inline Transform& prerotate(const RotationType& rotation);
564
565 EIGEN_DEVICE_FUNC Transform& shear(const Scalar& sx, const Scalar& sy);
566 EIGEN_DEVICE_FUNC Transform& preshear(const Scalar& sx, const Scalar& sy);
567
568 EIGEN_DEVICE_FUNC inline Transform& operator=(const TranslationType& t);
569
570 EIGEN_DEVICE_FUNC
571 inline Transform& operator*=(const TranslationType& t) { return translate(t.vector()); }
572
573 EIGEN_DEVICE_FUNC inline Transform operator*(const TranslationType& t) const;
574
575 EIGEN_DEVICE_FUNC
576 inline Transform& operator=(const UniformScaling<Scalar>& t);
577
578 EIGEN_DEVICE_FUNC
579 inline Transform& operator*=(const UniformScaling<Scalar>& s) { return scale(s.factor()); }
580
581 EIGEN_DEVICE_FUNC
582 inline TransformTimeDiagonalReturnType operator*(const UniformScaling<Scalar>& s) const
583 {
585 res.scale(s.factor());
586 return res;
587 }
588
589 EIGEN_DEVICE_FUNC
590 inline Transform& operator*=(const DiagonalMatrix<Scalar,Dim>& s) { linearExt() *= s; return *this; }
591
592 template<typename Derived>
593 EIGEN_DEVICE_FUNC inline Transform& operator=(const RotationBase<Derived,Dim>& r);
594 template<typename Derived>
595 EIGEN_DEVICE_FUNC inline Transform& operator*=(const RotationBase<Derived,Dim>& r) { return rotate(r.toRotationMatrix()); }
596 template<typename Derived>
597 EIGEN_DEVICE_FUNC inline Transform operator*(const RotationBase<Derived,Dim>& r) const;
598
599 typedef typename internal::conditional<int(Mode)==Isometry,ConstLinearPart,const LinearMatrixType>::type RotationReturnType;
600 EIGEN_DEVICE_FUNC RotationReturnType rotation() const;
601
602 template<typename RotationMatrixType, typename ScalingMatrixType>
603 EIGEN_DEVICE_FUNC
604 void computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const;
605 template<typename ScalingMatrixType, typename RotationMatrixType>
606 EIGEN_DEVICE_FUNC
607 void computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const;
608
609 template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
610 EIGEN_DEVICE_FUNC
611 Transform& fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
612 const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale);
613
614 EIGEN_DEVICE_FUNC
615 inline Transform inverse(TransformTraits traits = (TransformTraits)Mode) const;
616
618 EIGEN_DEVICE_FUNC const Scalar* data() const { return m_matrix.data(); }
620 EIGEN_DEVICE_FUNC Scalar* data() { return m_matrix.data(); }
621
627 template<typename NewScalarType>
628 EIGEN_DEVICE_FUNC inline typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type cast() const
629 { return typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type(*this); }
630
632 template<typename OtherScalarType>
633 EIGEN_DEVICE_FUNC inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Options>& other)
634 {
635 check_template_params();
636 m_matrix = other.matrix().template cast<Scalar>();
637 }
638
643 EIGEN_DEVICE_FUNC bool isApprox(const Transform& other, const typename NumTraits<Scalar>::Real& prec = NumTraits<Scalar>::dummy_precision()) const
644 { return m_matrix.isApprox(other.m_matrix, prec); }
645
648 EIGEN_DEVICE_FUNC void makeAffine()
649 {
650 internal::transform_make_affine<int(Mode)>::run(m_matrix);
651 }
652
657 EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt()
658 { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
663 EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt() const
664 { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
665
670 EIGEN_DEVICE_FUNC inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt()
671 { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
676 EIGEN_DEVICE_FUNC inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt() const
677 { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
678
679
680 #ifdef EIGEN_TRANSFORM_PLUGIN
681 #include EIGEN_TRANSFORM_PLUGIN
682 #endif
683
684protected:
685 #ifndef EIGEN_PARSED_BY_DOXYGEN
686 EIGEN_DEVICE_FUNC static EIGEN_STRONG_INLINE void check_template_params()
687 {
688 EIGEN_STATIC_ASSERT((Options & (DontAlign|RowMajor)) == Options, INVALID_MATRIX_TEMPLATE_PARAMETERS)
689 }
690 #endif
691
692};
693
695typedef Transform<float,2,Isometry> Isometry2f;
697typedef Transform<float,3,Isometry> Isometry3f;
699typedef Transform<double,2,Isometry> Isometry2d;
701typedef Transform<double,3,Isometry> Isometry3d;
702
704typedef Transform<float,2,Affine> Affine2f;
706typedef Transform<float,3,Affine> Affine3f;
708typedef Transform<double,2,Affine> Affine2d;
710typedef Transform<double,3,Affine> Affine3d;
711
713typedef Transform<float,2,AffineCompact> AffineCompact2f;
715typedef Transform<float,3,AffineCompact> AffineCompact3f;
717typedef Transform<double,2,AffineCompact> AffineCompact2d;
719typedef Transform<double,3,AffineCompact> AffineCompact3d;
720
722typedef Transform<float,2,Projective> Projective2f;
724typedef Transform<float,3,Projective> Projective3f;
726typedef Transform<double,2,Projective> Projective2d;
728typedef Transform<double,3,Projective> Projective3d;
729
730/**************************
731*** Optional QT support ***
732**************************/
733
734#ifdef EIGEN_QT_SUPPORT
739template<typename Scalar, int Dim, int Mode,int Options>
741{
742 check_template_params();
743 *this = other;
744}
745
750template<typename Scalar, int Dim, int Mode,int Options>
752{
753 EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
754 if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
755 m_matrix << other.m11(), other.m21(), other.dx(),
756 other.m12(), other.m22(), other.dy();
757 else
758 m_matrix << other.m11(), other.m21(), other.dx(),
759 other.m12(), other.m22(), other.dy(),
760 0, 0, 1;
761 return *this;
762}
763
770template<typename Scalar, int Dim, int Mode, int Options>
772{
773 check_template_params();
774 EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
775 return QMatrix(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
776 m_matrix.coeff(0,1), m_matrix.coeff(1,1),
777 m_matrix.coeff(0,2), m_matrix.coeff(1,2));
778}
779
784template<typename Scalar, int Dim, int Mode,int Options>
786{
787 check_template_params();
788 *this = other;
789}
790
795template<typename Scalar, int Dim, int Mode, int Options>
797{
798 check_template_params();
799 EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
800 if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
801 m_matrix << other.m11(), other.m21(), other.dx(),
802 other.m12(), other.m22(), other.dy();
803 else
804 m_matrix << other.m11(), other.m21(), other.dx(),
805 other.m12(), other.m22(), other.dy(),
806 other.m13(), other.m23(), other.m33();
807 return *this;
808}
809
814template<typename Scalar, int Dim, int Mode, int Options>
816{
817 EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
818 if (EIGEN_CONST_CONDITIONAL(Mode == int(AffineCompact)))
819 return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
820 m_matrix.coeff(0,1), m_matrix.coeff(1,1),
821 m_matrix.coeff(0,2), m_matrix.coeff(1,2));
822 else
823 return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0), m_matrix.coeff(2,0),
824 m_matrix.coeff(0,1), m_matrix.coeff(1,1), m_matrix.coeff(2,1),
825 m_matrix.coeff(0,2), m_matrix.coeff(1,2), m_matrix.coeff(2,2));
826}
827#endif
828
829/*********************
830*** Procedural API ***
831*********************/
832
837template<typename Scalar, int Dim, int Mode, int Options>
838template<typename OtherDerived>
839EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
841{
842 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
843 EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
844 linearExt().noalias() = (linearExt() * other.asDiagonal());
845 return *this;
846}
847
852template<typename Scalar, int Dim, int Mode, int Options>
854{
855 EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
856 linearExt() *= s;
857 return *this;
858}
859
864template<typename Scalar, int Dim, int Mode, int Options>
865template<typename OtherDerived>
866EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
868{
869 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
870 EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
871 affine().noalias() = (other.asDiagonal() * affine());
872 return *this;
873}
874
879template<typename Scalar, int Dim, int Mode, int Options>
881{
882 EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
883 m_matrix.template topRows<Dim>() *= s;
884 return *this;
885}
886
891template<typename Scalar, int Dim, int Mode, int Options>
892template<typename OtherDerived>
893EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
895{
896 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
897 translationExt() += linearExt() * other;
898 return *this;
899}
900
905template<typename Scalar, int Dim, int Mode, int Options>
906template<typename OtherDerived>
907EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
909{
910 EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
911 if(EIGEN_CONST_CONDITIONAL(int(Mode)==int(Projective)))
912 affine() += other * m_matrix.row(Dim);
913 else
914 translation() += other;
915 return *this;
916}
917
935template<typename Scalar, int Dim, int Mode, int Options>
936template<typename RotationType>
937EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
939{
940 linearExt() *= internal::toRotationMatrix<Scalar,Dim>(rotation);
941 return *this;
942}
943
951template<typename Scalar, int Dim, int Mode, int Options>
952template<typename RotationType>
953EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
955{
956 m_matrix.template block<Dim,HDim>(0,0) = internal::toRotationMatrix<Scalar,Dim>(rotation)
957 * m_matrix.template block<Dim,HDim>(0,0);
958 return *this;
959}
960
966template<typename Scalar, int Dim, int Mode, int Options>
967EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
969{
970 EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
971 EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
972 VectorType tmp = linear().col(0)*sy + linear().col(1);
973 linear() << linear().col(0) + linear().col(1)*sx, tmp;
974 return *this;
975}
976
982template<typename Scalar, int Dim, int Mode, int Options>
983EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
985{
986 EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
987 EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
988 m_matrix.template block<Dim,HDim>(0,0) = LinearMatrixType(1, sx, sy, 1) * m_matrix.template block<Dim,HDim>(0,0);
989 return *this;
990}
991
992/******************************************************
993*** Scaling, Translation and Rotation compatibility ***
994******************************************************/
995
996template<typename Scalar, int Dim, int Mode, int Options>
997EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const TranslationType& t)
998{
999 linear().setIdentity();
1000 translation() = t.vector();
1001 makeAffine();
1002 return *this;
1003}
1004
1005template<typename Scalar, int Dim, int Mode, int Options>
1006EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const TranslationType& t) const
1007{
1008 Transform res = *this;
1009 res.translate(t.vector());
1010 return res;
1011}
1012
1013template<typename Scalar, int Dim, int Mode, int Options>
1014EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const UniformScaling<Scalar>& s)
1015{
1016 m_matrix.setZero();
1017 linear().diagonal().fill(s.factor());
1018 makeAffine();
1019 return *this;
1020}
1021
1022template<typename Scalar, int Dim, int Mode, int Options>
1023template<typename Derived>
1024EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const RotationBase<Derived,Dim>& r)
1025{
1026 linear() = internal::toRotationMatrix<Scalar,Dim>(r);
1027 translation().setZero();
1028 makeAffine();
1029 return *this;
1030}
1031
1032template<typename Scalar, int Dim, int Mode, int Options>
1033template<typename Derived>
1034EIGEN_DEVICE_FUNC inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const RotationBase<Derived,Dim>& r) const
1035{
1036 Transform res = *this;
1037 res.rotate(r.derived());
1038 return res;
1039}
1040
1041/************************
1042*** Special functions ***
1043************************/
1044
1045namespace internal {
1046template<int Mode> struct transform_rotation_impl {
1047 template<typename TransformType>
1048 EIGEN_DEVICE_FUNC static inline
1049 const typename TransformType::LinearMatrixType run(const TransformType& t)
1050 {
1051 typedef typename TransformType::LinearMatrixType LinearMatrixType;
1052 LinearMatrixType result;
1053 t.computeRotationScaling(&result, (LinearMatrixType*)0);
1054 return result;
1055 }
1056};
1057template<> struct transform_rotation_impl<Isometry> {
1058 template<typename TransformType>
1059 EIGEN_DEVICE_FUNC static inline
1060 typename TransformType::ConstLinearPart run(const TransformType& t)
1061 {
1062 return t.linear();
1063 }
1064};
1065}
1076template<typename Scalar, int Dim, int Mode, int Options>
1077EIGEN_DEVICE_FUNC
1078typename Transform<Scalar,Dim,Mode,Options>::RotationReturnType
1080{
1081 return internal::transform_rotation_impl<Mode>::run(*this);
1082}
1083
1084
1096template<typename Scalar, int Dim, int Mode, int Options>
1097template<typename RotationMatrixType, typename ScalingMatrixType>
1098EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const
1099{
1100 // Note that JacobiSVD is faster than BDCSVD for small matrices.
1102
1103 Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant() < Scalar(0) ? Scalar(-1) : Scalar(1); // so x has absolute value 1
1104 VectorType sv(svd.singularValues());
1105 sv.coeffRef(Dim-1) *= x;
1106 if(scaling) *scaling = svd.matrixV() * sv.asDiagonal() * svd.matrixV().adjoint();
1107 if(rotation)
1108 {
1109 LinearMatrixType m(svd.matrixU());
1110 m.col(Dim-1) *= x;
1111 *rotation = m * svd.matrixV().adjoint();
1112 }
1113}
1114
1126template<typename Scalar, int Dim, int Mode, int Options>
1127template<typename ScalingMatrixType, typename RotationMatrixType>
1128EIGEN_DEVICE_FUNC void Transform<Scalar,Dim,Mode,Options>::computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const
1129{
1130 // Note that JacobiSVD is faster than BDCSVD for small matrices.
1132
1133 Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant() < Scalar(0) ? Scalar(-1) : Scalar(1); // so x has absolute value 1
1134 VectorType sv(svd.singularValues());
1135 sv.coeffRef(Dim-1) *= x;
1136 if(scaling) *scaling = svd.matrixU() * sv.asDiagonal() * svd.matrixU().adjoint();
1137 if(rotation)
1138 {
1139 LinearMatrixType m(svd.matrixU());
1140 m.col(Dim-1) *= x;
1141 *rotation = m * svd.matrixV().adjoint();
1142 }
1143}
1144
1148template<typename Scalar, int Dim, int Mode, int Options>
1149template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
1150EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>&
1152 const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale)
1153{
1154 linear() = internal::toRotationMatrix<Scalar,Dim>(orientation);
1155 linear() *= scale.asDiagonal();
1156 translation() = position;
1157 makeAffine();
1158 return *this;
1159}
1160
1161namespace internal {
1162
1163template<int Mode>
1164struct transform_make_affine
1165{
1166 template<typename MatrixType>
1167 EIGEN_DEVICE_FUNC static void run(MatrixType &mat)
1168 {
1169 static const int Dim = MatrixType::ColsAtCompileTime-1;
1170 mat.template block<1,Dim>(Dim,0).setZero();
1171 mat.coeffRef(Dim,Dim) = typename MatrixType::Scalar(1);
1172 }
1173};
1174
1175template<>
1176struct transform_make_affine<AffineCompact>
1177{
1178 template<typename MatrixType> EIGEN_DEVICE_FUNC static void run(MatrixType &) { }
1179};
1180
1181// selector needed to avoid taking the inverse of a 3x4 matrix
1182template<typename TransformType, int Mode=TransformType::Mode>
1183struct projective_transform_inverse
1184{
1185 EIGEN_DEVICE_FUNC static inline void run(const TransformType&, TransformType&)
1186 {}
1187};
1188
1189template<typename TransformType>
1190struct projective_transform_inverse<TransformType, Projective>
1191{
1192 EIGEN_DEVICE_FUNC static inline void run(const TransformType& m, TransformType& res)
1193 {
1194 res.matrix() = m.matrix().inverse();
1195 }
1196};
1197
1198} // end namespace internal
1199
1200
1221template<typename Scalar, int Dim, int Mode, int Options>
1222EIGEN_DEVICE_FUNC Transform<Scalar,Dim,Mode,Options>
1224{
1225 Transform res;
1226 if (hint == Projective)
1227 {
1228 internal::projective_transform_inverse<Transform>::run(*this, res);
1229 }
1230 else
1231 {
1232 if (hint == Isometry)
1233 {
1234 res.matrix().template topLeftCorner<Dim,Dim>() = linear().transpose();
1235 }
1236 else if(hint&Affine)
1237 {
1238 res.matrix().template topLeftCorner<Dim,Dim>() = linear().inverse();
1239 }
1240 else
1241 {
1242 eigen_assert(false && "Invalid transform traits in Transform::Inverse");
1243 }
1244 // translation and remaining parts
1245 res.matrix().template topRightCorner<Dim,1>()
1246 = - res.matrix().template topLeftCorner<Dim,Dim>() * translation();
1247 res.makeAffine(); // we do need this, because in the beginning res is uninitialized
1248 }
1249 return res;
1250}
1251
1252namespace internal {
1253
1254/*****************************************************
1255*** Specializations of take affine part ***
1256*****************************************************/
1257
1258template<typename TransformType> struct transform_take_affine_part {
1259 typedef typename TransformType::MatrixType MatrixType;
1260 typedef typename TransformType::AffinePart AffinePart;
1261 typedef typename TransformType::ConstAffinePart ConstAffinePart;
1262 static inline AffinePart run(MatrixType& m)
1263 { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
1264 static inline ConstAffinePart run(const MatrixType& m)
1265 { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
1266};
1267
1268template<typename Scalar, int Dim, int Options>
1269struct transform_take_affine_part<Transform<Scalar,Dim,AffineCompact, Options> > {
1271 static inline MatrixType& run(MatrixType& m) { return m; }
1272 static inline const MatrixType& run(const MatrixType& m) { return m; }
1273};
1274
1275/*****************************************************
1276*** Specializations of construct from matrix ***
1277*****************************************************/
1278
1279template<typename Other, int Mode, int Options, int Dim, int HDim>
1280struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,Dim>
1281{
1282 static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
1283 {
1284 transform->linear() = other;
1285 transform->translation().setZero();
1286 transform->makeAffine();
1287 }
1288};
1289
1290template<typename Other, int Mode, int Options, int Dim, int HDim>
1291struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,HDim>
1292{
1293 static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
1294 {
1295 transform->affine() = other;
1296 transform->makeAffine();
1297 }
1298};
1299
1300template<typename Other, int Mode, int Options, int Dim, int HDim>
1301struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, HDim,HDim>
1302{
1303 static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
1304 { transform->matrix() = other; }
1305};
1306
1307template<typename Other, int Options, int Dim, int HDim>
1308struct transform_construct_from_matrix<Other, AffineCompact,Options,Dim,HDim, HDim,HDim>
1309{
1310 static inline void run(Transform<typename Other::Scalar,Dim,AffineCompact,Options> *transform, const Other& other)
1311 { transform->matrix() = other.template block<Dim,HDim>(0,0); }
1312};
1313
1314/**********************************************************
1315*** Specializations of operator* with rhs EigenBase ***
1316**********************************************************/
1317
1318template<int LhsMode,int RhsMode>
1319struct transform_product_result
1320{
1321 enum
1322 {
1323 Mode =
1324 (LhsMode == (int)Projective || RhsMode == (int)Projective ) ? Projective :
1325 (LhsMode == (int)Affine || RhsMode == (int)Affine ) ? Affine :
1326 (LhsMode == (int)AffineCompact || RhsMode == (int)AffineCompact ) ? AffineCompact :
1327 (LhsMode == (int)Isometry || RhsMode == (int)Isometry ) ? Isometry : Projective
1328 };
1329};
1330
1331template< typename TransformType, typename MatrixType, int RhsCols>
1332struct transform_right_product_impl< TransformType, MatrixType, 0, RhsCols>
1333{
1334 typedef typename MatrixType::PlainObject ResultType;
1335
1336 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
1337 {
1338 return T.matrix() * other;
1339 }
1340};
1341
1342template< typename TransformType, typename MatrixType, int RhsCols>
1343struct transform_right_product_impl< TransformType, MatrixType, 1, RhsCols>
1344{
1345 enum {
1346 Dim = TransformType::Dim,
1347 HDim = TransformType::HDim,
1348 OtherRows = MatrixType::RowsAtCompileTime,
1349 OtherCols = MatrixType::ColsAtCompileTime
1350 };
1351
1352 typedef typename MatrixType::PlainObject ResultType;
1353
1354 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
1355 {
1356 EIGEN_STATIC_ASSERT(OtherRows==HDim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
1357
1358 typedef Block<ResultType, Dim, OtherCols, int(MatrixType::RowsAtCompileTime)==Dim> TopLeftLhs;
1359
1360 ResultType res(other.rows(),other.cols());
1361 TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() = T.affine() * other;
1362 res.row(OtherRows-1) = other.row(OtherRows-1);
1363
1364 return res;
1365 }
1366};
1367
1368template< typename TransformType, typename MatrixType, int RhsCols>
1369struct transform_right_product_impl< TransformType, MatrixType, 2, RhsCols>
1370{
1371 enum {
1372 Dim = TransformType::Dim,
1373 HDim = TransformType::HDim,
1374 OtherRows = MatrixType::RowsAtCompileTime,
1375 OtherCols = MatrixType::ColsAtCompileTime
1376 };
1377
1378 typedef typename MatrixType::PlainObject ResultType;
1379
1380 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
1381 {
1382 EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
1383
1384 typedef Block<ResultType, Dim, OtherCols, true> TopLeftLhs;
1385 ResultType res(Replicate<typename TransformType::ConstTranslationPart, 1, OtherCols>(T.translation(),1,other.cols()));
1386 TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() += T.linear() * other;
1387
1388 return res;
1389 }
1390};
1391
1392template< typename TransformType, typename MatrixType >
1393struct transform_right_product_impl< TransformType, MatrixType, 2, 1> // rhs is a vector of size Dim
1394{
1395 typedef typename TransformType::MatrixType TransformMatrix;
1396 enum {
1397 Dim = TransformType::Dim,
1398 HDim = TransformType::HDim,
1399 OtherRows = MatrixType::RowsAtCompileTime,
1400 WorkingRows = EIGEN_PLAIN_ENUM_MIN(TransformMatrix::RowsAtCompileTime,HDim)
1401 };
1402
1403 typedef typename MatrixType::PlainObject ResultType;
1404
1405 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ResultType run(const TransformType& T, const MatrixType& other)
1406 {
1407 EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
1408
1409 Matrix<typename ResultType::Scalar, Dim+1, 1> rhs;
1410 rhs.template head<Dim>() = other; rhs[Dim] = typename ResultType::Scalar(1);
1411 Matrix<typename ResultType::Scalar, WorkingRows, 1> res(T.matrix() * rhs);
1412 return res.template head<Dim>();
1413 }
1414};
1415
1416/**********************************************************
1417*** Specializations of operator* with lhs EigenBase ***
1418**********************************************************/
1419
1420// generic HDim x HDim matrix * T => Projective
1421template<typename Other,int Mode, int Options, int Dim, int HDim>
1422struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, HDim,HDim>
1423{
1424 typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
1425 typedef typename TransformType::MatrixType MatrixType;
1426 typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
1427 static ResultType run(const Other& other,const TransformType& tr)
1428 { return ResultType(other * tr.matrix()); }
1429};
1430
1431// generic HDim x HDim matrix * AffineCompact => Projective
1432template<typename Other, int Options, int Dim, int HDim>
1433struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, HDim,HDim>
1434{
1435 typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
1436 typedef typename TransformType::MatrixType MatrixType;
1437 typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
1438 static ResultType run(const Other& other,const TransformType& tr)
1439 {
1440 ResultType res;
1441 res.matrix().noalias() = other.template block<HDim,Dim>(0,0) * tr.matrix();
1442 res.matrix().col(Dim) += other.col(Dim);
1443 return res;
1444 }
1445};
1446
1447// affine matrix * T
1448template<typename Other,int Mode, int Options, int Dim, int HDim>
1449struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,HDim>
1450{
1451 typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
1452 typedef typename TransformType::MatrixType MatrixType;
1453 typedef TransformType ResultType;
1454 static ResultType run(const Other& other,const TransformType& tr)
1455 {
1456 ResultType res;
1457 res.affine().noalias() = other * tr.matrix();
1458 res.matrix().row(Dim) = tr.matrix().row(Dim);
1459 return res;
1460 }
1461};
1462
1463// affine matrix * AffineCompact
1464template<typename Other, int Options, int Dim, int HDim>
1465struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, Dim,HDim>
1466{
1467 typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
1468 typedef typename TransformType::MatrixType MatrixType;
1469 typedef TransformType ResultType;
1470 static ResultType run(const Other& other,const TransformType& tr)
1471 {
1472 ResultType res;
1473 res.matrix().noalias() = other.template block<Dim,Dim>(0,0) * tr.matrix();
1474 res.translation() += other.col(Dim);
1475 return res;
1476 }
1477};
1478
1479// linear matrix * T
1480template<typename Other,int Mode, int Options, int Dim, int HDim>
1481struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,Dim>
1482{
1483 typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
1484 typedef typename TransformType::MatrixType MatrixType;
1485 typedef TransformType ResultType;
1486 static ResultType run(const Other& other, const TransformType& tr)
1487 {
1488 TransformType res;
1489 if(Mode!=int(AffineCompact))
1490 res.matrix().row(Dim) = tr.matrix().row(Dim);
1491 res.matrix().template topRows<Dim>().noalias()
1492 = other * tr.matrix().template topRows<Dim>();
1493 return res;
1494 }
1495};
1496
1497/**********************************************************
1498*** Specializations of operator* with another Transform ***
1499**********************************************************/
1500
1501template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
1502struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,false >
1503{
1504 enum { ResultMode = transform_product_result<LhsMode,RhsMode>::Mode };
1505 typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
1506 typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
1507 typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
1508 static ResultType run(const Lhs& lhs, const Rhs& rhs)
1509 {
1510 ResultType res;
1511 res.linear() = lhs.linear() * rhs.linear();
1512 res.translation() = lhs.linear() * rhs.translation() + lhs.translation();
1513 res.makeAffine();
1514 return res;
1515 }
1516};
1517
1518template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
1519struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,true >
1520{
1521 typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
1522 typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
1523 typedef Transform<Scalar,Dim,Projective> ResultType;
1524 static ResultType run(const Lhs& lhs, const Rhs& rhs)
1525 {
1526 return ResultType( lhs.matrix() * rhs.matrix() );
1527 }
1528};
1529
1530template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
1531struct transform_transform_product_impl<Transform<Scalar,Dim,AffineCompact,LhsOptions>,Transform<Scalar,Dim,Projective,RhsOptions>,true >
1532{
1533 typedef Transform<Scalar,Dim,AffineCompact,LhsOptions> Lhs;
1534 typedef Transform<Scalar,Dim,Projective,RhsOptions> Rhs;
1535 typedef Transform<Scalar,Dim,Projective> ResultType;
1536 static ResultType run(const Lhs& lhs, const Rhs& rhs)
1537 {
1538 ResultType res;
1539 res.matrix().template topRows<Dim>() = lhs.matrix() * rhs.matrix();
1540 res.matrix().row(Dim) = rhs.matrix().row(Dim);
1541 return res;
1542 }
1543};
1544
1545template<typename Scalar, int Dim, int LhsOptions, int RhsOptions>
1546struct transform_transform_product_impl<Transform<Scalar,Dim,Projective,LhsOptions>,Transform<Scalar,Dim,AffineCompact,RhsOptions>,true >
1547{
1548 typedef Transform<Scalar,Dim,Projective,LhsOptions> Lhs;
1549 typedef Transform<Scalar,Dim,AffineCompact,RhsOptions> Rhs;
1550 typedef Transform<Scalar,Dim,Projective> ResultType;
1551 static ResultType run(const Lhs& lhs, const Rhs& rhs)
1552 {
1553 ResultType res(lhs.matrix().template leftCols<Dim>() * rhs.matrix());
1554 res.matrix().col(Dim) += lhs.matrix().col(Dim);
1555 return res;
1556 }
1557};
1558
1559} // end namespace internal
1560
1561} // end namespace Eigen
1562
1563#endif // EIGEN_TRANSFORM_H
Expression of a fixed-size or dynamic-size block.
Definition: Block.h:105
Two-sided Jacobi SVD decomposition of a rectangular matrix.
Definition: JacobiSVD.h:490
Base class for all dense matrices, vectors, and expressions.
Definition: MatrixBase.h:50
const DiagonalWrapper< const Derived > asDiagonal() const
Definition: DiagonalMatrix.h:325
The matrix class, also used for vectors and row-vectors.
Definition: Matrix.h:180
Scalar & coeffRef(Index rowId, Index colId)
Definition: PlainObjectBase.h:175
const Scalar & coeff(Index rowId, Index colId) const
Definition: PlainObjectBase.h:152
Derived & setZero(Index size)
Definition: CwiseNullaryOp.h:562
const Scalar * data() const
Definition: PlainObjectBase.h:247
const SingularValuesType & singularValues() const
Definition: SVDBase.h:129
const MatrixUType & matrixU() const
Definition: SVDBase.h:101
const MatrixVType & matrixV() const
Definition: SVDBase.h:117
Represents an homogeneous transformation in a N dimensional space.
Definition: Transform.h:205
const MatrixType & matrix() const
Definition: Transform.h:389
Transform & preshear(const Scalar &sx, const Scalar &sy)
Definition: Transform.h:984
Transform()
Definition: Transform.h:259
Transform & operator=(const EigenBase< OtherDerived > &other)
Definition: Transform.h:297
Block< MatrixType, Dim, Dim, int(Mode)==(AffineCompact) &&(int(Options)&RowMajor)==0 > LinearPart
Definition: Transform.h:226
void computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const
Definition: Transform.h:1128
Transform(const Transform< OtherScalarType, Dim, Mode, Options > &other)
Definition: Transform.h:633
MatrixType & matrix()
Definition: Transform.h:391
EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar, _Dim==Dynamic ? Dynamic :(_Dim+1) *(_Dim+1)) enum
Definition: Transform.h:207
internal::make_proper_matrix_type< Scalar, Rows, HDim, Options >::type MatrixType
Definition: Transform.h:220
const Block< ConstMatrixType, Dim, 1,!(internal::traits< MatrixType >::Flags &RowMajorBit)> ConstTranslationPart
Definition: Transform.h:242
Matrix< Scalar, Dim, Dim, Options > LinearMatrixType
Definition: Transform.h:224
Eigen::Index Index
Definition: Transform.h:218
_Scalar Scalar
Definition: Transform.h:216
Transform< Scalar, Dim, TransformTimeDiagonalMode > TransformTimeDiagonalReturnType
Definition: Transform.h:249
static const Transform Identity()
Returns an identity transformation.
Definition: Transform.h:533
Scalar * data()
Definition: Transform.h:620
internal::cast_return_type< Transform, Transform< NewScalarType, Dim, Mode, Options > >::type cast() const
Definition: Transform.h:628
internal::conditional< int(Mode)==int(AffineCompact), MatrixType &, Block< MatrixType, Dim, HDim > >::type AffinePart
Definition: Transform.h:232
Translation< Scalar, Dim > TranslationType
Definition: Transform.h:244
internal::conditional< int(Mode)==int(AffineCompact), constMatrixType &, constBlock< constMatrixType, Dim, HDim > >::type ConstAffinePart
Definition: Transform.h:236
void computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const
Definition: Transform.h:1098
const Block< ConstMatrixType, Dim, Dim, int(Mode)==(AffineCompact) &&(int(Options)&RowMajor)==0 > ConstLinearPart
Definition: Transform.h:228
ConstAffinePart affine() const
Definition: Transform.h:399
Scalar operator()(Index row, Index col) const
Definition: Transform.h:383
AffinePart affine()
Definition: Transform.h:401
friend const internal::transform_left_product_impl< OtherDerived, Mode, Options, _Dim, _Dim+1 >::ResultType operator*(const EigenBase< OtherDerived > &a, const Transform &b)
Definition: Transform.h:447
TranslationPart translation()
Definition: Transform.h:406
Block< MatrixType, Dim, 1,!(internal::traits< MatrixType >::Flags &RowMajorBit)> TranslationPart
Definition: Transform.h:240
Matrix< Scalar, Dim, 1 > VectorType
Definition: Transform.h:238
Transform inverse(TransformTraits traits=(TransformTraits) Mode) const
Definition: Transform.h:1223
bool isApprox(const Transform &other, const typename NumTraits< Scalar >::Real &prec=NumTraits< Scalar >::dummy_precision()) const
Definition: Transform.h:643
void makeAffine()
Definition: Transform.h:648
void setIdentity()
Definition: Transform.h:527
LinearPart linear()
Definition: Transform.h:396
RotationReturnType rotation() const
Definition: Transform.h:1079
QMatrix toQMatrix(void) const
Definition: Transform.h:771
ConstTranslationPart translation() const
Definition: Transform.h:404
const Scalar * data() const
Definition: Transform.h:618
Transform & shear(const Scalar &sx, const Scalar &sy)
Definition: Transform.h:968
QTransform toQTransform(void) const
Definition: Transform.h:815
Transform(const EigenBase< OtherDerived > &other)
Definition: Transform.h:286
const MatrixType ConstMatrixType
Definition: Transform.h:222
ConstLinearPart linear() const
Definition: Transform.h:394
Represents a translation transformation.
Definition: Translation.h:31
TransformTraits
Definition: Constants.h:455
@ DontAlign
Definition: Constants.h:325
@ RowMajor
Definition: Constants.h:321
@ ComputeFullV
Definition: Constants.h:397
@ ComputeFullU
Definition: Constants.h:393
@ Affine
Definition: Constants.h:460
@ Projective
Definition: Constants.h:464
@ AffineCompact
Definition: Constants.h:462
@ Isometry
Definition: Constants.h:457
const unsigned int RowMajorBit
Definition: Constants.h:66
Namespace containing all symbols from the Eigen library.
Definition: Core:141
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const int Dynamic
Definition: Constants.h:22
Definition: EigenBase.h:30
Derived & derived()
Definition: EigenBase.h:46
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:233