Another set of UI messages fixes and tweaks! No functional changes.
[blender.git] / extern / Eigen3 / Eigen / src / Geometry / 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 // Eigen is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Lesser General Public
10 // License as published by the Free Software Foundation; either
11 // version 3 of the License, or (at your option) any later version.
12 //
13 // Alternatively, you can redistribute it and/or
14 // modify it under the terms of the GNU General Public License as
15 // published by the Free Software Foundation; either version 2 of
16 // the License, or (at your option) any later version.
17 //
18 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
19 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
21 // GNU General Public License for more details.
22 //
23 // You should have received a copy of the GNU Lesser General Public
24 // License and a copy of the GNU General Public License along with
25 // Eigen. If not, see <http://www.gnu.org/licenses/>.
26
27 #ifndef EIGEN_TRANSFORM_H
28 #define EIGEN_TRANSFORM_H
29
30 namespace internal {
31
32 template<typename Transform>
33 struct transform_traits
34 {
35   enum
36   {
37     Dim = Transform::Dim,
38     HDim = Transform::HDim,
39     Mode = Transform::Mode,
40     IsProjective = (Mode==Projective)
41   };
42 };
43
44 template< typename TransformType,
45           typename MatrixType,
46           int Case = transform_traits<TransformType>::IsProjective ? 0
47                    : int(MatrixType::RowsAtCompileTime) == int(transform_traits<TransformType>::HDim) ? 1
48                    : 2>
49 struct transform_right_product_impl;
50
51 template< typename Other,
52           int Mode,
53           int Options,
54           int Dim,
55           int HDim,
56           int OtherRows=Other::RowsAtCompileTime,
57           int OtherCols=Other::ColsAtCompileTime>
58 struct transform_left_product_impl;
59
60 template< typename Lhs,
61           typename Rhs,
62           bool AnyProjective = 
63             transform_traits<Lhs>::IsProjective ||
64             transform_traits<Lhs>::IsProjective>
65 struct transform_transform_product_impl;
66
67 template< typename Other,
68           int Mode,
69           int Options,
70           int Dim,
71           int HDim,
72           int OtherRows=Other::RowsAtCompileTime,
73           int OtherCols=Other::ColsAtCompileTime>
74 struct transform_construct_from_matrix;
75
76 template<typename TransformType> struct transform_take_affine_part;
77
78 } // end namespace internal
79
80 /** \geometry_module \ingroup Geometry_Module
81   *
82   * \class Transform
83   *
84   * \brief Represents an homogeneous transformation in a N dimensional space
85   *
86   * \tparam _Scalar the scalar type, i.e., the type of the coefficients
87   * \tparam _Dim the dimension of the space
88   * \tparam _Mode the type of the transformation. Can be:
89   *              - #Affine: the transformation is stored as a (Dim+1)^2 matrix,
90   *                         where the last row is assumed to be [0 ... 0 1].
91   *              - #AffineCompact: the transformation is stored as a (Dim)x(Dim+1) matrix.
92   *              - #Projective: the transformation is stored as a (Dim+1)^2 matrix
93   *                             without any assumption.
94   * \tparam _Options has the same meaning as in class Matrix. It allows to specify DontAlign and/or RowMajor.
95   *                  These Options are passed directly to the underlying matrix type.
96   *
97   * The homography is internally represented and stored by a matrix which
98   * is available through the matrix() method. To understand the behavior of
99   * this class you have to think a Transform object as its internal
100   * matrix representation. The chosen convention is right multiply:
101   *
102   * \code v' = T * v \endcode
103   *
104   * Therefore, an affine transformation matrix M is shaped like this:
105   *
106   * \f$ \left( \begin{array}{cc}
107   * linear & translation\\
108   * 0 ... 0 & 1
109   * \end{array} \right) \f$
110   *
111   * Note that for a projective transformation the last row can be anything,
112   * and then the interpretation of different parts might be sightly different.
113   *
114   * However, unlike a plain matrix, the Transform class provides many features
115   * simplifying both its assembly and usage. In particular, it can be composed
116   * with any other transformations (Transform,Translation,RotationBase,Matrix)
117   * and can be directly used to transform implicit homogeneous vectors. All these
118   * operations are handled via the operator*. For the composition of transformations,
119   * its principle consists to first convert the right/left hand sides of the product
120   * to a compatible (Dim+1)^2 matrix and then perform a pure matrix product.
121   * Of course, internally, operator* tries to perform the minimal number of operations
122   * according to the nature of each terms. Likewise, when applying the transform
123   * to non homogeneous vectors, the latters are automatically promoted to homogeneous
124   * one before doing the matrix product. The convertions to homogeneous representations
125   * are performed as follow:
126   *
127   * \b Translation t (Dim)x(1):
128   * \f$ \left( \begin{array}{cc}
129   * I & t \\
130   * 0\,...\,0 & 1
131   * \end{array} \right) \f$
132   *
133   * \b Rotation R (Dim)x(Dim):
134   * \f$ \left( \begin{array}{cc}
135   * R & 0\\
136   * 0\,...\,0 & 1
137   * \end{array} \right) \f$
138   *
139   * \b Linear \b Matrix L (Dim)x(Dim):
140   * \f$ \left( \begin{array}{cc}
141   * L & 0\\
142   * 0\,...\,0 & 1
143   * \end{array} \right) \f$
144   *
145   * \b Affine \b Matrix A (Dim)x(Dim+1):
146   * \f$ \left( \begin{array}{c}
147   * A\\
148   * 0\,...\,0\,1
149   * \end{array} \right) \f$
150   *
151   * \b Column \b vector v (Dim)x(1):
152   * \f$ \left( \begin{array}{c}
153   * v\\
154   * 1
155   * \end{array} \right) \f$
156   *
157   * \b Set \b of \b column \b vectors V1...Vn (Dim)x(n):
158   * \f$ \left( \begin{array}{ccc}
159   * v_1 & ... & v_n\\
160   * 1 & ... & 1
161   * \end{array} \right) \f$
162   *
163   * The concatenation of a Transform object with any kind of other transformation
164   * always returns a Transform object.
165   *
166   * A little exception to the "as pure matrix product" rule is the case of the
167   * transformation of non homogeneous vectors by an affine transformation. In
168   * that case the last matrix row can be ignored, and the product returns non
169   * homogeneous vectors.
170   *
171   * Since, for instance, a Dim x Dim matrix is interpreted as a linear transformation,
172   * it is not possible to directly transform Dim vectors stored in a Dim x Dim matrix.
173   * The solution is either to use a Dim x Dynamic matrix or explicitly request a
174   * vector transformation by making the vector homogeneous:
175   * \code
176   * m' = T * m.colwise().homogeneous();
177   * \endcode
178   * Note that there is zero overhead.
179   *
180   * Conversion methods from/to Qt's QMatrix and QTransform are available if the
181   * preprocessor token EIGEN_QT_SUPPORT is defined.
182   *
183   * This class can be extended with the help of the plugin mechanism described on the page
184   * \ref TopicCustomizingEigen by defining the preprocessor symbol \c EIGEN_TRANSFORM_PLUGIN.
185   *
186   * \sa class Matrix, class Quaternion
187   */
188 template<typename _Scalar, int _Dim, int _Mode, int _Options>
189 class Transform
190 {
191 public:
192   EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1))
193   enum {
194     Mode = _Mode,
195     Options = _Options,
196     Dim = _Dim,     ///< space dimension in which the transformation holds
197     HDim = _Dim+1,  ///< size of a respective homogeneous vector
198     Rows = int(Mode)==(AffineCompact) ? Dim : HDim
199   };
200   /** the scalar type of the coefficients */
201   typedef _Scalar Scalar;
202   typedef DenseIndex Index;
203   /** type of the matrix used to represent the transformation */
204   typedef typename internal::make_proper_matrix_type<Scalar,Rows,HDim,Options>::type MatrixType;
205   /** constified MatrixType */
206   typedef const MatrixType ConstMatrixType;
207   /** type of the matrix used to represent the linear part of the transformation */
208   typedef Matrix<Scalar,Dim,Dim,Options> LinearMatrixType;
209   /** type of read/write reference to the linear part of the transformation */
210   typedef Block<MatrixType,Dim,Dim> LinearPart;
211   /** type of read reference to the linear part of the transformation */
212   typedef const Block<ConstMatrixType,Dim,Dim> ConstLinearPart;
213   /** type of read/write reference to the affine part of the transformation */
214   typedef typename internal::conditional<int(Mode)==int(AffineCompact),
215                               MatrixType&,
216                               Block<MatrixType,Dim,HDim> >::type AffinePart;
217   /** type of read reference to the affine part of the transformation */
218   typedef typename internal::conditional<int(Mode)==int(AffineCompact),
219                               const MatrixType&,
220                               const Block<const MatrixType,Dim,HDim> >::type ConstAffinePart;
221   /** type of a vector */
222   typedef Matrix<Scalar,Dim,1> VectorType;
223   /** type of a read/write reference to the translation part of the rotation */
224   typedef Block<MatrixType,Dim,1> TranslationPart;
225   /** type of a read reference to the translation part of the rotation */
226   typedef const Block<ConstMatrixType,Dim,1> ConstTranslationPart;
227   /** corresponding translation type */
228   typedef Translation<Scalar,Dim> TranslationType;
229   
230   // this intermediate enum is needed to avoid an ICE with gcc 3.4 and 4.0
231   enum { TransformTimeDiagonalMode = ((Mode==int(Isometry))?Affine:int(Mode)) };
232   /** The return type of the product between a diagonal matrix and a transform */
233   typedef Transform<Scalar,Dim,TransformTimeDiagonalMode> TransformTimeDiagonalReturnType;
234
235 protected:
236
237   MatrixType m_matrix;
238
239 public:
240
241   /** Default constructor without initialization of the meaningful coefficients.
242     * If Mode==Affine, then the last row is set to [0 ... 0 1] */
243   inline Transform()
244   {
245     check_template_params();
246     if (int(Mode)==Affine)
247       makeAffine();
248   }
249
250   inline Transform(const Transform& other)
251   {
252     check_template_params();
253     m_matrix = other.m_matrix;
254   }
255
256   inline explicit Transform(const TranslationType& t)
257   {
258     check_template_params();
259     *this = t;
260   }
261   inline explicit Transform(const UniformScaling<Scalar>& s)
262   {
263     check_template_params();
264     *this = s;
265   }
266   template<typename Derived>
267   inline explicit Transform(const RotationBase<Derived, Dim>& r)
268   {
269     check_template_params();
270     *this = r;
271   }
272
273   inline Transform& operator=(const Transform& other)
274   { m_matrix = other.m_matrix; return *this; }
275
276   typedef internal::transform_take_affine_part<Transform> take_affine_part;
277
278   /** Constructs and initializes a transformation from a Dim^2 or a (Dim+1)^2 matrix. */
279   template<typename OtherDerived>
280   inline explicit Transform(const EigenBase<OtherDerived>& other)
281   {
282     check_template_params();
283     internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
284   }
285
286   /** Set \c *this from a Dim^2 or (Dim+1)^2 matrix. */
287   template<typename OtherDerived>
288   inline Transform& operator=(const EigenBase<OtherDerived>& other)
289   {
290     internal::transform_construct_from_matrix<OtherDerived,Mode,Options,Dim,HDim>::run(this, other.derived());
291     return *this;
292   }
293   
294   template<int OtherOptions>
295   inline Transform(const Transform<Scalar,Dim,Mode,OtherOptions>& other)
296   {
297     check_template_params();
298     // only the options change, we can directly copy the matrices
299     m_matrix = other.matrix();
300   }
301
302   template<int OtherMode,int OtherOptions>
303   inline Transform(const Transform<Scalar,Dim,OtherMode,OtherOptions>& other)
304   {
305     check_template_params();
306     // prevent conversions as:
307     // Affine | AffineCompact | Isometry = Projective
308     EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Projective), Mode==int(Projective)),
309                         YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
310
311     // prevent conversions as:
312     // Isometry = Affine | AffineCompact
313     EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(OtherMode==int(Affine)||OtherMode==int(AffineCompact), Mode!=int(Isometry)),
314                         YOU_PERFORMED_AN_INVALID_TRANSFORMATION_CONVERSION)
315
316     enum { ModeIsAffineCompact = Mode == int(AffineCompact),
317            OtherModeIsAffineCompact = OtherMode == int(AffineCompact)
318     };
319
320     if(ModeIsAffineCompact == OtherModeIsAffineCompact)
321     {
322       // We need the block expression because the code is compiled for all
323       // combinations of transformations and will trigger a compile time error
324       // if one tries to assign the matrices directly
325       m_matrix.template block<Dim,Dim+1>(0,0) = other.matrix().template block<Dim,Dim+1>(0,0);
326       makeAffine();
327     }
328     else if(OtherModeIsAffineCompact)
329     {
330       typedef typename Transform<Scalar,Dim,OtherMode,OtherOptions>::MatrixType OtherMatrixType;
331       internal::transform_construct_from_matrix<OtherMatrixType,Mode,Options,Dim,HDim>::run(this, other.matrix());
332     }
333     else
334     {
335       // here we know that Mode == AffineCompact and OtherMode != AffineCompact.
336       // if OtherMode were Projective, the static assert above would already have caught it.
337       // So the only possibility is that OtherMode == Affine
338       linear() = other.linear();
339       translation() = other.translation();
340     }
341   }
342
343   template<typename OtherDerived>
344   Transform(const ReturnByValue<OtherDerived>& other)
345   {
346     check_template_params();
347     other.evalTo(*this);
348   }
349
350   template<typename OtherDerived>
351   Transform& operator=(const ReturnByValue<OtherDerived>& other)
352   {
353     other.evalTo(*this);
354     return *this;
355   }
356
357   #ifdef EIGEN_QT_SUPPORT
358   inline Transform(const QMatrix& other);
359   inline Transform& operator=(const QMatrix& other);
360   inline QMatrix toQMatrix(void) const;
361   inline Transform(const QTransform& other);
362   inline Transform& operator=(const QTransform& other);
363   inline QTransform toQTransform(void) const;
364   #endif
365
366   /** shortcut for m_matrix(row,col);
367     * \sa MatrixBase::operator(Index,Index) const */
368   inline Scalar operator() (Index row, Index col) const { return m_matrix(row,col); }
369   /** shortcut for m_matrix(row,col);
370     * \sa MatrixBase::operator(Index,Index) */
371   inline Scalar& operator() (Index row, Index col) { return m_matrix(row,col); }
372
373   /** \returns a read-only expression of the transformation matrix */
374   inline const MatrixType& matrix() const { return m_matrix; }
375   /** \returns a writable expression of the transformation matrix */
376   inline MatrixType& matrix() { return m_matrix; }
377
378   /** \returns a read-only expression of the linear part of the transformation */
379   inline ConstLinearPart linear() const { return m_matrix.template block<Dim,Dim>(0,0); }
380   /** \returns a writable expression of the linear part of the transformation */
381   inline LinearPart linear() { return m_matrix.template block<Dim,Dim>(0,0); }
382
383   /** \returns a read-only expression of the Dim x HDim affine part of the transformation */
384   inline ConstAffinePart affine() const { return take_affine_part::run(m_matrix); }
385   /** \returns a writable expression of the Dim x HDim affine part of the transformation */
386   inline AffinePart affine() { return take_affine_part::run(m_matrix); }
387
388   /** \returns a read-only expression of the translation vector of the transformation */
389   inline ConstTranslationPart translation() const { return m_matrix.template block<Dim,1>(0,Dim); }
390   /** \returns a writable expression of the translation vector of the transformation */
391   inline TranslationPart translation() { return m_matrix.template block<Dim,1>(0,Dim); }
392
393   /** \returns an expression of the product between the transform \c *this and a matrix expression \a other
394     *
395     * The right hand side \a other might be either:
396     * \li a vector of size Dim,
397     * \li an homogeneous vector of size Dim+1,
398     * \li a set of vectors of size Dim x Dynamic,
399     * \li a set of homogeneous vectors of size Dim+1 x Dynamic,
400     * \li a linear transformation matrix of size Dim x Dim,
401     * \li an affine transformation matrix of size Dim x Dim+1,
402     * \li a transformation matrix of size Dim+1 x Dim+1.
403     */
404   // note: this function is defined here because some compilers cannot find the respective declaration
405   template<typename OtherDerived>
406   EIGEN_STRONG_INLINE const typename internal::transform_right_product_impl<Transform, OtherDerived>::ResultType
407   operator * (const EigenBase<OtherDerived> &other) const
408   { return internal::transform_right_product_impl<Transform, OtherDerived>::run(*this,other.derived()); }
409
410   /** \returns the product expression of a transformation matrix \a a times a transform \a b
411     *
412     * The left hand side \a other might be either:
413     * \li a linear transformation matrix of size Dim x Dim,
414     * \li an affine transformation matrix of size Dim x Dim+1,
415     * \li a general transformation matrix of size Dim+1 x Dim+1.
416     */
417   template<typename OtherDerived> friend
418   inline const typename internal::transform_left_product_impl<OtherDerived,Mode,Options,_Dim,_Dim+1>::ResultType
419     operator * (const EigenBase<OtherDerived> &a, const Transform &b)
420   { return internal::transform_left_product_impl<OtherDerived,Mode,Options,Dim,HDim>::run(a.derived(),b); }
421
422   /** \returns The product expression of a transform \a a times a diagonal matrix \a b
423     *
424     * The rhs diagonal matrix is interpreted as an affine scaling transformation. The
425     * product results in a Transform of the same type (mode) as the lhs only if the lhs 
426     * mode is no isometry. In that case, the returned transform is an affinity.
427     */
428   template<typename DiagonalDerived>
429   inline const TransformTimeDiagonalReturnType
430     operator * (const DiagonalBase<DiagonalDerived> &b) const
431   {
432     TransformTimeDiagonalReturnType res(*this);
433     res.linear() *= b;
434     return res;
435   }
436
437   /** \returns The product expression of a diagonal matrix \a a times a transform \a b
438     *
439     * The lhs diagonal matrix is interpreted as an affine scaling transformation. The
440     * product results in a Transform of the same type (mode) as the lhs only if the lhs 
441     * mode is no isometry. In that case, the returned transform is an affinity.
442     */
443   template<typename DiagonalDerived>
444   friend inline TransformTimeDiagonalReturnType
445     operator * (const DiagonalBase<DiagonalDerived> &a, const Transform &b)
446   {
447     TransformTimeDiagonalReturnType res;
448     res.linear().noalias() = a*b.linear();
449     res.translation().noalias() = a*b.translation();
450     if (Mode!=int(AffineCompact))
451       res.matrix().row(Dim) = b.matrix().row(Dim);
452     return res;
453   }
454
455   template<typename OtherDerived>
456   inline Transform& operator*=(const EigenBase<OtherDerived>& other) { return *this = *this * other; }
457
458   /** Concatenates two transformations */
459   inline const Transform operator * (const Transform& other) const
460   {
461     return internal::transform_transform_product_impl<Transform,Transform>::run(*this,other);
462   }
463
464   /** Concatenates two different transformations */
465   template<int OtherMode,int OtherOptions>
466   inline const typename internal::transform_transform_product_impl<
467     Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::ResultType
468     operator * (const Transform<Scalar,Dim,OtherMode,OtherOptions>& other) const
469   {
470     return internal::transform_transform_product_impl<Transform,Transform<Scalar,Dim,OtherMode,OtherOptions> >::run(*this,other);
471   }
472
473   /** \sa MatrixBase::setIdentity() */
474   void setIdentity() { m_matrix.setIdentity(); }
475
476   /**
477    * \brief Returns an identity transformation.
478    * \todo In the future this function should be returning a Transform expression.
479    */
480   static const Transform Identity()
481   {
482     return Transform(MatrixType::Identity());
483   }
484
485   template<typename OtherDerived>
486   inline Transform& scale(const MatrixBase<OtherDerived> &other);
487
488   template<typename OtherDerived>
489   inline Transform& prescale(const MatrixBase<OtherDerived> &other);
490
491   inline Transform& scale(Scalar s);
492   inline Transform& prescale(Scalar s);
493
494   template<typename OtherDerived>
495   inline Transform& translate(const MatrixBase<OtherDerived> &other);
496
497   template<typename OtherDerived>
498   inline Transform& pretranslate(const MatrixBase<OtherDerived> &other);
499
500   template<typename RotationType>
501   inline Transform& rotate(const RotationType& rotation);
502
503   template<typename RotationType>
504   inline Transform& prerotate(const RotationType& rotation);
505
506   Transform& shear(Scalar sx, Scalar sy);
507   Transform& preshear(Scalar sx, Scalar sy);
508
509   inline Transform& operator=(const TranslationType& t);
510   inline Transform& operator*=(const TranslationType& t) { return translate(t.vector()); }
511   inline Transform operator*(const TranslationType& t) const;
512
513   inline Transform& operator=(const UniformScaling<Scalar>& t);
514   inline Transform& operator*=(const UniformScaling<Scalar>& s) { return scale(s.factor()); }
515   inline Transform operator*(const UniformScaling<Scalar>& s) const;
516
517   inline Transform& operator*=(const DiagonalMatrix<Scalar,Dim>& s) { linear() *= s; return *this; }
518
519   template<typename Derived>
520   inline Transform& operator=(const RotationBase<Derived,Dim>& r);
521   template<typename Derived>
522   inline Transform& operator*=(const RotationBase<Derived,Dim>& r) { return rotate(r.toRotationMatrix()); }
523   template<typename Derived>
524   inline Transform operator*(const RotationBase<Derived,Dim>& r) const;
525
526   const LinearMatrixType rotation() const;
527   template<typename RotationMatrixType, typename ScalingMatrixType>
528   void computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const;
529   template<typename ScalingMatrixType, typename RotationMatrixType>
530   void computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const;
531
532   template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
533   Transform& fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
534     const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale);
535
536   inline Transform inverse(TransformTraits traits = (TransformTraits)Mode) const;
537
538   /** \returns a const pointer to the column major internal matrix */
539   const Scalar* data() const { return m_matrix.data(); }
540   /** \returns a non-const pointer to the column major internal matrix */
541   Scalar* data() { return m_matrix.data(); }
542
543   /** \returns \c *this with scalar type casted to \a NewScalarType
544     *
545     * Note that if \a NewScalarType is equal to the current scalar type of \c *this
546     * then this function smartly returns a const reference to \c *this.
547     */
548   template<typename NewScalarType>
549   inline typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type cast() const
550   { return typename internal::cast_return_type<Transform,Transform<NewScalarType,Dim,Mode,Options> >::type(*this); }
551
552   /** Copy constructor with scalar type conversion */
553   template<typename OtherScalarType>
554   inline explicit Transform(const Transform<OtherScalarType,Dim,Mode,Options>& other)
555   {
556     check_template_params();
557     m_matrix = other.matrix().template cast<Scalar>();
558   }
559
560   /** \returns \c true if \c *this is approximately equal to \a other, within the precision
561     * determined by \a prec.
562     *
563     * \sa MatrixBase::isApprox() */
564   bool isApprox(const Transform& other, typename NumTraits<Scalar>::Real prec = NumTraits<Scalar>::dummy_precision()) const
565   { return m_matrix.isApprox(other.m_matrix, prec); }
566
567   /** Sets the last row to [0 ... 0 1]
568     */
569   void makeAffine()
570   {
571     if(int(Mode)!=int(AffineCompact))
572     {
573       matrix().template block<1,Dim>(Dim,0).setZero();
574       matrix().coeffRef(Dim,Dim) = 1;
575     }
576   }
577
578   /** \internal
579     * \returns the Dim x Dim linear part if the transformation is affine,
580     *          and the HDim x Dim part for projective transformations.
581     */
582   inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt()
583   { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
584   /** \internal
585     * \returns the Dim x Dim linear part if the transformation is affine,
586     *          and the HDim x Dim part for projective transformations.
587     */
588   inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,Dim> linearExt() const
589   { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,Dim>(0,0); }
590
591   /** \internal
592     * \returns the translation part if the transformation is affine,
593     *          and the last column for projective transformations.
594     */
595   inline Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt()
596   { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
597   /** \internal
598     * \returns the translation part if the transformation is affine,
599     *          and the last column for projective transformations.
600     */
601   inline const Block<MatrixType,int(Mode)==int(Projective)?HDim:Dim,1> translationExt() const
602   { return m_matrix.template block<int(Mode)==int(Projective)?HDim:Dim,1>(0,Dim); }
603
604
605   #ifdef EIGEN_TRANSFORM_PLUGIN
606   #include EIGEN_TRANSFORM_PLUGIN
607   #endif
608   
609 protected:
610   #ifndef EIGEN_PARSED_BY_DOXYGEN
611     EIGEN_STRONG_INLINE static void check_template_params()
612     {
613       EIGEN_STATIC_ASSERT((Options & (DontAlign|RowMajor)) == Options, INVALID_MATRIX_TEMPLATE_PARAMETERS)
614     }
615   #endif
616
617 };
618
619 /** \ingroup Geometry_Module */
620 typedef Transform<float,2,Isometry> Isometry2f;
621 /** \ingroup Geometry_Module */
622 typedef Transform<float,3,Isometry> Isometry3f;
623 /** \ingroup Geometry_Module */
624 typedef Transform<double,2,Isometry> Isometry2d;
625 /** \ingroup Geometry_Module */
626 typedef Transform<double,3,Isometry> Isometry3d;
627
628 /** \ingroup Geometry_Module */
629 typedef Transform<float,2,Affine> Affine2f;
630 /** \ingroup Geometry_Module */
631 typedef Transform<float,3,Affine> Affine3f;
632 /** \ingroup Geometry_Module */
633 typedef Transform<double,2,Affine> Affine2d;
634 /** \ingroup Geometry_Module */
635 typedef Transform<double,3,Affine> Affine3d;
636
637 /** \ingroup Geometry_Module */
638 typedef Transform<float,2,AffineCompact> AffineCompact2f;
639 /** \ingroup Geometry_Module */
640 typedef Transform<float,3,AffineCompact> AffineCompact3f;
641 /** \ingroup Geometry_Module */
642 typedef Transform<double,2,AffineCompact> AffineCompact2d;
643 /** \ingroup Geometry_Module */
644 typedef Transform<double,3,AffineCompact> AffineCompact3d;
645
646 /** \ingroup Geometry_Module */
647 typedef Transform<float,2,Projective> Projective2f;
648 /** \ingroup Geometry_Module */
649 typedef Transform<float,3,Projective> Projective3f;
650 /** \ingroup Geometry_Module */
651 typedef Transform<double,2,Projective> Projective2d;
652 /** \ingroup Geometry_Module */
653 typedef Transform<double,3,Projective> Projective3d;
654
655 /**************************
656 *** Optional QT support ***
657 **************************/
658
659 #ifdef EIGEN_QT_SUPPORT
660 /** Initializes \c *this from a QMatrix assuming the dimension is 2.
661   *
662   * This function is available only if the token EIGEN_QT_SUPPORT is defined.
663   */
664 template<typename Scalar, int Dim, int Mode,int Options>
665 Transform<Scalar,Dim,Mode,Options>::Transform(const QMatrix& other)
666 {
667   check_template_params();
668   *this = other;
669 }
670
671 /** Set \c *this from a QMatrix assuming the dimension is 2.
672   *
673   * This function is available only if the token EIGEN_QT_SUPPORT is defined.
674   */
675 template<typename Scalar, int Dim, int Mode,int Options>
676 Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QMatrix& other)
677 {
678   EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
679   m_matrix << other.m11(), other.m21(), other.dx(),
680               other.m12(), other.m22(), other.dy(),
681               0, 0, 1;
682   return *this;
683 }
684
685 /** \returns a QMatrix from \c *this assuming the dimension is 2.
686   *
687   * \warning this conversion might loss data if \c *this is not affine
688   *
689   * This function is available only if the token EIGEN_QT_SUPPORT is defined.
690   */
691 template<typename Scalar, int Dim, int Mode, int Options>
692 QMatrix Transform<Scalar,Dim,Mode,Options>::toQMatrix(void) const
693 {
694   check_template_params();
695   EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
696   return QMatrix(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
697                  m_matrix.coeff(0,1), m_matrix.coeff(1,1),
698                  m_matrix.coeff(0,2), m_matrix.coeff(1,2));
699 }
700
701 /** Initializes \c *this from a QTransform assuming the dimension is 2.
702   *
703   * This function is available only if the token EIGEN_QT_SUPPORT is defined.
704   */
705 template<typename Scalar, int Dim, int Mode,int Options>
706 Transform<Scalar,Dim,Mode,Options>::Transform(const QTransform& other)
707 {
708   check_template_params();
709   *this = other;
710 }
711
712 /** Set \c *this from a QTransform assuming the dimension is 2.
713   *
714   * This function is available only if the token EIGEN_QT_SUPPORT is defined.
715   */
716 template<typename Scalar, int Dim, int Mode, int Options>
717 Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const QTransform& other)
718 {
719   check_template_params();
720   EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
721   if (Mode == int(AffineCompact))
722     m_matrix << other.m11(), other.m21(), other.dx(),
723                 other.m12(), other.m22(), other.dy();
724   else
725     m_matrix << other.m11(), other.m21(), other.dx(),
726                 other.m12(), other.m22(), other.dy(),
727                 other.m13(), other.m23(), other.m33();
728   return *this;
729 }
730
731 /** \returns a QTransform from \c *this assuming the dimension is 2.
732   *
733   * This function is available only if the token EIGEN_QT_SUPPORT is defined.
734   */
735 template<typename Scalar, int Dim, int Mode, int Options>
736 QTransform Transform<Scalar,Dim,Mode,Options>::toQTransform(void) const
737 {
738   EIGEN_STATIC_ASSERT(Dim==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
739   if (Mode == int(AffineCompact))
740     return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0),
741                       m_matrix.coeff(0,1), m_matrix.coeff(1,1),
742                       m_matrix.coeff(0,2), m_matrix.coeff(1,2));
743   else
744     return QTransform(m_matrix.coeff(0,0), m_matrix.coeff(1,0), m_matrix.coeff(2,0),
745                       m_matrix.coeff(0,1), m_matrix.coeff(1,1), m_matrix.coeff(2,1),
746                       m_matrix.coeff(0,2), m_matrix.coeff(1,2), m_matrix.coeff(2,2));
747 }
748 #endif
749
750 /*********************
751 *** Procedural API ***
752 *********************/
753
754 /** Applies on the right the non uniform scale transformation represented
755   * by the vector \a other to \c *this and returns a reference to \c *this.
756   * \sa prescale()
757   */
758 template<typename Scalar, int Dim, int Mode, int Options>
759 template<typename OtherDerived>
760 Transform<Scalar,Dim,Mode,Options>&
761 Transform<Scalar,Dim,Mode,Options>::scale(const MatrixBase<OtherDerived> &other)
762 {
763   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
764   EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
765   linearExt().noalias() = (linearExt() * other.asDiagonal());
766   return *this;
767 }
768
769 /** Applies on the right a uniform scale of a factor \a c to \c *this
770   * and returns a reference to \c *this.
771   * \sa prescale(Scalar)
772   */
773 template<typename Scalar, int Dim, int Mode, int Options>
774 inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::scale(Scalar s)
775 {
776   EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
777   linearExt() *= s;
778   return *this;
779 }
780
781 /** Applies on the left the non uniform scale transformation represented
782   * by the vector \a other to \c *this and returns a reference to \c *this.
783   * \sa scale()
784   */
785 template<typename Scalar, int Dim, int Mode, int Options>
786 template<typename OtherDerived>
787 Transform<Scalar,Dim,Mode,Options>&
788 Transform<Scalar,Dim,Mode,Options>::prescale(const MatrixBase<OtherDerived> &other)
789 {
790   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
791   EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
792   m_matrix.template block<Dim,HDim>(0,0).noalias() = (other.asDiagonal() * m_matrix.template block<Dim,HDim>(0,0));
793   return *this;
794 }
795
796 /** Applies on the left a uniform scale of a factor \a c to \c *this
797   * and returns a reference to \c *this.
798   * \sa scale(Scalar)
799   */
800 template<typename Scalar, int Dim, int Mode, int Options>
801 inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::prescale(Scalar s)
802 {
803   EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
804   m_matrix.template topRows<Dim>() *= s;
805   return *this;
806 }
807
808 /** Applies on the right the translation matrix represented by the vector \a other
809   * to \c *this and returns a reference to \c *this.
810   * \sa pretranslate()
811   */
812 template<typename Scalar, int Dim, int Mode, int Options>
813 template<typename OtherDerived>
814 Transform<Scalar,Dim,Mode,Options>&
815 Transform<Scalar,Dim,Mode,Options>::translate(const MatrixBase<OtherDerived> &other)
816 {
817   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
818   translationExt() += linearExt() * other;
819   return *this;
820 }
821
822 /** Applies on the left the translation matrix represented by the vector \a other
823   * to \c *this and returns a reference to \c *this.
824   * \sa translate()
825   */
826 template<typename Scalar, int Dim, int Mode, int Options>
827 template<typename OtherDerived>
828 Transform<Scalar,Dim,Mode,Options>&
829 Transform<Scalar,Dim,Mode,Options>::pretranslate(const MatrixBase<OtherDerived> &other)
830 {
831   EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(OtherDerived,int(Dim))
832   if(int(Mode)==int(Projective))
833     affine() += other * m_matrix.row(Dim);
834   else
835     translation() += other;
836   return *this;
837 }
838
839 /** Applies on the right the rotation represented by the rotation \a rotation
840   * to \c *this and returns a reference to \c *this.
841   *
842   * The template parameter \a RotationType is the type of the rotation which
843   * must be known by internal::toRotationMatrix<>.
844   *
845   * Natively supported types includes:
846   *   - any scalar (2D),
847   *   - a Dim x Dim matrix expression,
848   *   - a Quaternion (3D),
849   *   - a AngleAxis (3D)
850   *
851   * This mechanism is easily extendable to support user types such as Euler angles,
852   * or a pair of Quaternion for 4D rotations.
853   *
854   * \sa rotate(Scalar), class Quaternion, class AngleAxis, prerotate(RotationType)
855   */
856 template<typename Scalar, int Dim, int Mode, int Options>
857 template<typename RotationType>
858 Transform<Scalar,Dim,Mode,Options>&
859 Transform<Scalar,Dim,Mode,Options>::rotate(const RotationType& rotation)
860 {
861   linearExt() *= internal::toRotationMatrix<Scalar,Dim>(rotation);
862   return *this;
863 }
864
865 /** Applies on the left the rotation represented by the rotation \a rotation
866   * to \c *this and returns a reference to \c *this.
867   *
868   * See rotate() for further details.
869   *
870   * \sa rotate()
871   */
872 template<typename Scalar, int Dim, int Mode, int Options>
873 template<typename RotationType>
874 Transform<Scalar,Dim,Mode,Options>&
875 Transform<Scalar,Dim,Mode,Options>::prerotate(const RotationType& rotation)
876 {
877   m_matrix.template block<Dim,HDim>(0,0) = internal::toRotationMatrix<Scalar,Dim>(rotation)
878                                          * m_matrix.template block<Dim,HDim>(0,0);
879   return *this;
880 }
881
882 /** Applies on the right the shear transformation represented
883   * by the vector \a other to \c *this and returns a reference to \c *this.
884   * \warning 2D only.
885   * \sa preshear()
886   */
887 template<typename Scalar, int Dim, int Mode, int Options>
888 Transform<Scalar,Dim,Mode,Options>&
889 Transform<Scalar,Dim,Mode,Options>::shear(Scalar sx, Scalar sy)
890 {
891   EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
892   EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
893   VectorType tmp = linear().col(0)*sy + linear().col(1);
894   linear() << linear().col(0) + linear().col(1)*sx, tmp;
895   return *this;
896 }
897
898 /** Applies on the left the shear transformation represented
899   * by the vector \a other to \c *this and returns a reference to \c *this.
900   * \warning 2D only.
901   * \sa shear()
902   */
903 template<typename Scalar, int Dim, int Mode, int Options>
904 Transform<Scalar,Dim,Mode,Options>&
905 Transform<Scalar,Dim,Mode,Options>::preshear(Scalar sx, Scalar sy)
906 {
907   EIGEN_STATIC_ASSERT(int(Dim)==2, YOU_MADE_A_PROGRAMMING_MISTAKE)
908   EIGEN_STATIC_ASSERT(Mode!=int(Isometry), THIS_METHOD_IS_ONLY_FOR_SPECIFIC_TRANSFORMATIONS)
909   m_matrix.template block<Dim,HDim>(0,0) = LinearMatrixType(1, sx, sy, 1) * m_matrix.template block<Dim,HDim>(0,0);
910   return *this;
911 }
912
913 /******************************************************
914 *** Scaling, Translation and Rotation compatibility ***
915 ******************************************************/
916
917 template<typename Scalar, int Dim, int Mode, int Options>
918 inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const TranslationType& t)
919 {
920   linear().setIdentity();
921   translation() = t.vector();
922   makeAffine();
923   return *this;
924 }
925
926 template<typename Scalar, int Dim, int Mode, int Options>
927 inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const TranslationType& t) const
928 {
929   Transform res = *this;
930   res.translate(t.vector());
931   return res;
932 }
933
934 template<typename Scalar, int Dim, int Mode, int Options>
935 inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const UniformScaling<Scalar>& s)
936 {
937   m_matrix.setZero();
938   linear().diagonal().fill(s.factor());
939   makeAffine();
940   return *this;
941 }
942
943 template<typename Scalar, int Dim, int Mode, int Options>
944 inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const UniformScaling<Scalar>& s) const
945 {
946   Transform res = *this;
947   res.scale(s.factor());
948   return res;
949 }
950
951 template<typename Scalar, int Dim, int Mode, int Options>
952 template<typename Derived>
953 inline Transform<Scalar,Dim,Mode,Options>& Transform<Scalar,Dim,Mode,Options>::operator=(const RotationBase<Derived,Dim>& r)
954 {
955   linear() = internal::toRotationMatrix<Scalar,Dim>(r);
956   translation().setZero();
957   makeAffine();
958   return *this;
959 }
960
961 template<typename Scalar, int Dim, int Mode, int Options>
962 template<typename Derived>
963 inline Transform<Scalar,Dim,Mode,Options> Transform<Scalar,Dim,Mode,Options>::operator*(const RotationBase<Derived,Dim>& r) const
964 {
965   Transform res = *this;
966   res.rotate(r.derived());
967   return res;
968 }
969
970 /************************
971 *** Special functions ***
972 ************************/
973
974 /** \returns the rotation part of the transformation
975   *
976   *
977   * \svd_module
978   *
979   * \sa computeRotationScaling(), computeScalingRotation(), class SVD
980   */
981 template<typename Scalar, int Dim, int Mode, int Options>
982 const typename Transform<Scalar,Dim,Mode,Options>::LinearMatrixType
983 Transform<Scalar,Dim,Mode,Options>::rotation() const
984 {
985   LinearMatrixType result;
986   computeRotationScaling(&result, (LinearMatrixType*)0);
987   return result;
988 }
989
990
991 /** decomposes the linear part of the transformation as a product rotation x scaling, the scaling being
992   * not necessarily positive.
993   *
994   * If either pointer is zero, the corresponding computation is skipped.
995   *
996   *
997   *
998   * \svd_module
999   *
1000   * \sa computeScalingRotation(), rotation(), class SVD
1001   */
1002 template<typename Scalar, int Dim, int Mode, int Options>
1003 template<typename RotationMatrixType, typename ScalingMatrixType>
1004 void Transform<Scalar,Dim,Mode,Options>::computeRotationScaling(RotationMatrixType *rotation, ScalingMatrixType *scaling) const
1005 {
1006   JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
1007
1008   Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant(); // so x has absolute value 1
1009   VectorType sv(svd.singularValues());
1010   sv.coeffRef(0) *= x;
1011   if(scaling) scaling->lazyAssign(svd.matrixV() * sv.asDiagonal() * svd.matrixV().adjoint());
1012   if(rotation)
1013   {
1014     LinearMatrixType m(svd.matrixU());
1015     m.col(0) /= x;
1016     rotation->lazyAssign(m * svd.matrixV().adjoint());
1017   }
1018 }
1019
1020 /** decomposes the linear part of the transformation as a product rotation x scaling, the scaling being
1021   * not necessarily positive.
1022   *
1023   * If either pointer is zero, the corresponding computation is skipped.
1024   *
1025   *
1026   *
1027   * \svd_module
1028   *
1029   * \sa computeRotationScaling(), rotation(), class SVD
1030   */
1031 template<typename Scalar, int Dim, int Mode, int Options>
1032 template<typename ScalingMatrixType, typename RotationMatrixType>
1033 void Transform<Scalar,Dim,Mode,Options>::computeScalingRotation(ScalingMatrixType *scaling, RotationMatrixType *rotation) const
1034 {
1035   JacobiSVD<LinearMatrixType> svd(linear(), ComputeFullU | ComputeFullV);
1036
1037   Scalar x = (svd.matrixU() * svd.matrixV().adjoint()).determinant(); // so x has absolute value 1
1038   VectorType sv(svd.singularValues());
1039   sv.coeffRef(0) *= x;
1040   if(scaling) scaling->lazyAssign(svd.matrixU() * sv.asDiagonal() * svd.matrixU().adjoint());
1041   if(rotation)
1042   {
1043     LinearMatrixType m(svd.matrixU());
1044     m.col(0) /= x;
1045     rotation->lazyAssign(m * svd.matrixV().adjoint());
1046   }
1047 }
1048
1049 /** Convenient method to set \c *this from a position, orientation and scale
1050   * of a 3D object.
1051   */
1052 template<typename Scalar, int Dim, int Mode, int Options>
1053 template<typename PositionDerived, typename OrientationType, typename ScaleDerived>
1054 Transform<Scalar,Dim,Mode,Options>&
1055 Transform<Scalar,Dim,Mode,Options>::fromPositionOrientationScale(const MatrixBase<PositionDerived> &position,
1056   const OrientationType& orientation, const MatrixBase<ScaleDerived> &scale)
1057 {
1058   linear() = internal::toRotationMatrix<Scalar,Dim>(orientation);
1059   linear() *= scale.asDiagonal();
1060   translation() = position;
1061   makeAffine();
1062   return *this;
1063 }
1064
1065 namespace internal {
1066
1067 // selector needed to avoid taking the inverse of a 3x4 matrix
1068 template<typename TransformType, int Mode=TransformType::Mode>
1069 struct projective_transform_inverse
1070 {
1071   static inline void run(const TransformType&, TransformType&)
1072   {}
1073 };
1074
1075 template<typename TransformType>
1076 struct projective_transform_inverse<TransformType, Projective>
1077 {
1078   static inline void run(const TransformType& m, TransformType& res)
1079   {
1080     res.matrix() = m.matrix().inverse();
1081   }
1082 };
1083
1084 } // end namespace internal
1085
1086
1087 /**
1088   *
1089   * \returns the inverse transformation according to some given knowledge
1090   * on \c *this.
1091   *
1092   * \param hint allows to optimize the inversion process when the transformation
1093   * is known to be not a general transformation (optional). The possible values are:
1094   *  - #Projective if the transformation is not necessarily affine, i.e., if the
1095   *    last row is not guaranteed to be [0 ... 0 1]
1096   *  - #Affine if the last row can be assumed to be [0 ... 0 1]
1097   *  - #Isometry if the transformation is only a concatenations of translations
1098   *    and rotations.
1099   *  The default is the template class parameter \c Mode.
1100   *
1101   * \warning unless \a traits is always set to NoShear or NoScaling, this function
1102   * requires the generic inverse method of MatrixBase defined in the LU module. If
1103   * you forget to include this module, then you will get hard to debug linking errors.
1104   *
1105   * \sa MatrixBase::inverse()
1106   */
1107 template<typename Scalar, int Dim, int Mode, int Options>
1108 Transform<Scalar,Dim,Mode,Options>
1109 Transform<Scalar,Dim,Mode,Options>::inverse(TransformTraits hint) const
1110 {
1111   Transform res;
1112   if (hint == Projective)
1113   {
1114     internal::projective_transform_inverse<Transform>::run(*this, res);
1115   }
1116   else
1117   {
1118     if (hint == Isometry)
1119     {
1120       res.matrix().template topLeftCorner<Dim,Dim>() = linear().transpose();
1121     }
1122     else if(hint&Affine)
1123     {
1124       res.matrix().template topLeftCorner<Dim,Dim>() = linear().inverse();
1125     }
1126     else
1127     {
1128       eigen_assert(false && "Invalid transform traits in Transform::Inverse");
1129     }
1130     // translation and remaining parts
1131     res.matrix().template topRightCorner<Dim,1>()
1132       = - res.matrix().template topLeftCorner<Dim,Dim>() * translation();
1133     res.makeAffine(); // we do need this, because in the beginning res is uninitialized
1134   }
1135   return res;
1136 }
1137
1138 namespace internal {
1139
1140 /*****************************************************
1141 *** Specializations of take affine part            ***
1142 *****************************************************/
1143
1144 template<typename TransformType> struct transform_take_affine_part {
1145   typedef typename TransformType::MatrixType MatrixType;
1146   typedef typename TransformType::AffinePart AffinePart;
1147   typedef typename TransformType::ConstAffinePart ConstAffinePart;
1148   static inline AffinePart run(MatrixType& m)
1149   { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
1150   static inline ConstAffinePart run(const MatrixType& m)
1151   { return m.template block<TransformType::Dim,TransformType::HDim>(0,0); }
1152 };
1153
1154 template<typename Scalar, int Dim, int Options>
1155 struct transform_take_affine_part<Transform<Scalar,Dim,AffineCompact, Options> > {
1156   typedef typename Transform<Scalar,Dim,AffineCompact,Options>::MatrixType MatrixType;
1157   static inline MatrixType& run(MatrixType& m) { return m; }
1158   static inline const MatrixType& run(const MatrixType& m) { return m; }
1159 };
1160
1161 /*****************************************************
1162 *** Specializations of construct from matrix       ***
1163 *****************************************************/
1164
1165 template<typename Other, int Mode, int Options, int Dim, int HDim>
1166 struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,Dim>
1167 {
1168   static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
1169   {
1170     transform->linear() = other;
1171     transform->translation().setZero();
1172     transform->makeAffine();
1173   }
1174 };
1175
1176 template<typename Other, int Mode, int Options, int Dim, int HDim>
1177 struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, Dim,HDim>
1178 {
1179   static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
1180   {
1181     transform->affine() = other;
1182     transform->makeAffine();
1183   }
1184 };
1185
1186 template<typename Other, int Mode, int Options, int Dim, int HDim>
1187 struct transform_construct_from_matrix<Other, Mode,Options,Dim,HDim, HDim,HDim>
1188 {
1189   static inline void run(Transform<typename Other::Scalar,Dim,Mode,Options> *transform, const Other& other)
1190   { transform->matrix() = other; }
1191 };
1192
1193 template<typename Other, int Options, int Dim, int HDim>
1194 struct transform_construct_from_matrix<Other, AffineCompact,Options,Dim,HDim, HDim,HDim>
1195 {
1196   static inline void run(Transform<typename Other::Scalar,Dim,AffineCompact,Options> *transform, const Other& other)
1197   { transform->matrix() = other.template block<Dim,HDim>(0,0); }
1198 };
1199
1200 /**********************************************************
1201 ***   Specializations of operator* with rhs EigenBase   ***
1202 **********************************************************/
1203
1204 template<int LhsMode,int RhsMode>
1205 struct transform_product_result
1206 {
1207   enum 
1208   { 
1209     Mode =
1210       (LhsMode == (int)Projective    || RhsMode == (int)Projective    ) ? Projective :
1211       (LhsMode == (int)Affine        || RhsMode == (int)Affine        ) ? Affine :
1212       (LhsMode == (int)AffineCompact || RhsMode == (int)AffineCompact ) ? AffineCompact :
1213       (LhsMode == (int)Isometry      || RhsMode == (int)Isometry      ) ? Isometry : Projective
1214   };
1215 };
1216
1217 template< typename TransformType, typename MatrixType >
1218 struct transform_right_product_impl< TransformType, MatrixType, 0 >
1219 {
1220   typedef typename MatrixType::PlainObject ResultType;
1221
1222   EIGEN_STRONG_INLINE static ResultType run(const TransformType& T, const MatrixType& other)
1223   {
1224     return T.matrix() * other;
1225   }
1226 };
1227
1228 template< typename TransformType, typename MatrixType >
1229 struct transform_right_product_impl< TransformType, MatrixType, 1 >
1230 {
1231   enum { 
1232     Dim = TransformType::Dim, 
1233     HDim = TransformType::HDim,
1234     OtherRows = MatrixType::RowsAtCompileTime,
1235     OtherCols = MatrixType::ColsAtCompileTime
1236   };
1237
1238   typedef typename MatrixType::PlainObject ResultType;
1239
1240   EIGEN_STRONG_INLINE static ResultType run(const TransformType& T, const MatrixType& other)
1241   {
1242     EIGEN_STATIC_ASSERT(OtherRows==HDim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
1243
1244     typedef Block<ResultType, Dim, OtherCols> TopLeftLhs;
1245
1246     ResultType res(other.rows(),other.cols());
1247     TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() = T.affine() * other;
1248     res.row(OtherRows-1) = other.row(OtherRows-1);
1249     
1250     return res;
1251   }
1252 };
1253
1254 template< typename TransformType, typename MatrixType >
1255 struct transform_right_product_impl< TransformType, MatrixType, 2 >
1256 {
1257   enum { 
1258     Dim = TransformType::Dim, 
1259     HDim = TransformType::HDim,
1260     OtherRows = MatrixType::RowsAtCompileTime,
1261     OtherCols = MatrixType::ColsAtCompileTime
1262   };
1263
1264   typedef typename MatrixType::PlainObject ResultType;
1265
1266   EIGEN_STRONG_INLINE static ResultType run(const TransformType& T, const MatrixType& other)
1267   {
1268     EIGEN_STATIC_ASSERT(OtherRows==Dim, YOU_MIXED_MATRICES_OF_DIFFERENT_SIZES);
1269
1270     typedef Block<ResultType, Dim, OtherCols> TopLeftLhs;
1271
1272     ResultType res(other.rows(),other.cols());
1273     TopLeftLhs(res, 0, 0, Dim, other.cols()).noalias() = T.linear() * other;
1274     TopLeftLhs(res, 0, 0, Dim, other.cols()).colwise() += T.translation();
1275
1276     return res;
1277   }
1278 };
1279
1280 /**********************************************************
1281 ***   Specializations of operator* with lhs EigenBase   ***
1282 **********************************************************/
1283
1284 // generic HDim x HDim matrix * T => Projective
1285 template<typename Other,int Mode, int Options, int Dim, int HDim>
1286 struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, HDim,HDim>
1287 {
1288   typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
1289   typedef typename TransformType::MatrixType MatrixType;
1290   typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
1291   static ResultType run(const Other& other,const TransformType& tr)
1292   { return ResultType(other * tr.matrix()); }
1293 };
1294
1295 // generic HDim x HDim matrix * AffineCompact => Projective
1296 template<typename Other, int Options, int Dim, int HDim>
1297 struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, HDim,HDim>
1298 {
1299   typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
1300   typedef typename TransformType::MatrixType MatrixType;
1301   typedef Transform<typename Other::Scalar,Dim,Projective,Options> ResultType;
1302   static ResultType run(const Other& other,const TransformType& tr)
1303   {
1304     ResultType res;
1305     res.matrix().noalias() = other.template block<HDim,Dim>(0,0) * tr.matrix();
1306     res.matrix().col(Dim) += other.col(Dim);
1307     return res;
1308   }
1309 };
1310
1311 // affine matrix * T
1312 template<typename Other,int Mode, int Options, int Dim, int HDim>
1313 struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,HDim>
1314 {
1315   typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
1316   typedef typename TransformType::MatrixType MatrixType;
1317   typedef TransformType ResultType;
1318   static ResultType run(const Other& other,const TransformType& tr)
1319   {
1320     ResultType res;
1321     res.affine().noalias() = other * tr.matrix();
1322     res.matrix().row(Dim) = tr.matrix().row(Dim);
1323     return res;
1324   }
1325 };
1326
1327 // affine matrix * AffineCompact
1328 template<typename Other, int Options, int Dim, int HDim>
1329 struct transform_left_product_impl<Other,AffineCompact,Options,Dim,HDim, Dim,HDim>
1330 {
1331   typedef Transform<typename Other::Scalar,Dim,AffineCompact,Options> TransformType;
1332   typedef typename TransformType::MatrixType MatrixType;
1333   typedef TransformType ResultType;
1334   static ResultType run(const Other& other,const TransformType& tr)
1335   {
1336     ResultType res;
1337     res.matrix().noalias() = other.template block<Dim,Dim>(0,0) * tr.matrix();
1338     res.translation() += other.col(Dim);
1339     return res;
1340   }
1341 };
1342
1343 // linear matrix * T
1344 template<typename Other,int Mode, int Options, int Dim, int HDim>
1345 struct transform_left_product_impl<Other,Mode,Options,Dim,HDim, Dim,Dim>
1346 {
1347   typedef Transform<typename Other::Scalar,Dim,Mode,Options> TransformType;
1348   typedef typename TransformType::MatrixType MatrixType;
1349   typedef TransformType ResultType;
1350   static ResultType run(const Other& other, const TransformType& tr)
1351   {
1352     TransformType res;
1353     if(Mode!=int(AffineCompact))
1354       res.matrix().row(Dim) = tr.matrix().row(Dim);
1355     res.matrix().template topRows<Dim>().noalias()
1356       = other * tr.matrix().template topRows<Dim>();
1357     return res;
1358   }
1359 };
1360
1361 /**********************************************************
1362 *** Specializations of operator* with another Transform ***
1363 **********************************************************/
1364
1365 template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
1366 struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,false >
1367 {
1368   enum { ResultMode = transform_product_result<LhsMode,RhsMode>::Mode };
1369   typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
1370   typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
1371   typedef Transform<Scalar,Dim,ResultMode,LhsOptions> ResultType;
1372   static ResultType run(const Lhs& lhs, const Rhs& rhs)
1373   {
1374     ResultType res;
1375     res.linear() = lhs.linear() * rhs.linear();
1376     res.translation() = lhs.linear() * rhs.translation() + lhs.translation();
1377     res.makeAffine();
1378     return res;
1379   }
1380 };
1381
1382 template<typename Scalar, int Dim, int LhsMode, int LhsOptions, int RhsMode, int RhsOptions>
1383 struct transform_transform_product_impl<Transform<Scalar,Dim,LhsMode,LhsOptions>,Transform<Scalar,Dim,RhsMode,RhsOptions>,true >
1384 {
1385   typedef Transform<Scalar,Dim,LhsMode,LhsOptions> Lhs;
1386   typedef Transform<Scalar,Dim,RhsMode,RhsOptions> Rhs;
1387   typedef Transform<Scalar,Dim,Projective> ResultType;
1388   static ResultType run(const Lhs& lhs, const Rhs& rhs)
1389   {
1390     return ResultType( lhs.matrix() * rhs.matrix() );
1391   }
1392 };
1393
1394 } // end namespace internal
1395
1396 #endif // EIGEN_TRANSFORM_H