vcglib: similarity.h Source File

00001 /****************************************************************************
00002 * VCGLib                                                            o o     *
00003 * Visual and Computer Graphics Library                            o     o   *
00004 *                                                                _   O  _   *
00005 * Copyright(C) 2004                                                \/)\/    *
00006 * Visual Computing Lab                                            /\/|      *
00007 * ISTI - Italian National Research Council                           |      *
00008 *                                                                    \      *
00009 * All rights reserved.                                                      *
00010 *                                                                           *
00011 * This program is free software; you can redistribute it and/or modify      *   
00012 * it under the terms of the GNU General Public License as published by      *
00013 * the Free Software Foundation; either version 2 of the License, or         *
00014 * (at your option) any later version.                                       *
00015 *                                                                           *
00016 * This program is distributed in the hope that it will be useful,           *
00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
00019 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
00020 * for more details.                                                         *
00021 *                                                                           *
00022 ****************************************************************************/
00023 /****************************************************************************
00024   History
00025 
00026 $Log: not supported by cvs2svn $
00027 Revision 1.16  2008/02/22 17:40:27  ponchio
00028 Fixed determinantt problem and quaternion problem.
00029 
00030 Revision 1.15  2008/02/21 11:34:08  ponchio
00031 refixed bug in FromMatrix
00032 
00033 Revision 1.14  2008/02/21 10:57:59  ponchio
00034 fixed bug in FromMatrix
00035 
00036 Revision 1.13  2008/02/21 10:30:18  benedetti
00037 corrected bug in FromMatrix
00038 
00039 Revision 1.12  2007/02/05 14:17:48  corsini
00040 add new ctor (build similarity from euler angles)
00041 
00042 Revision 1.11  2004/12/15 18:45:50  tommyfranken
00043 *** empty log message ***
00044 
00045 Revision 1.10  2004/10/07 13:55:47  ganovelli
00046 templated on the kind of class used to implement rotation
00047 (default is QUternion but it can be Matrix44 as well)
00048 
00049 Revision 1.9  2004/06/04 13:35:07  cignoni
00050 added InverseMatrix,
00051 
00052 Revision 1.8  2004/05/07 10:09:13  cignoni
00053 missing final newline
00054 
00055 Revision 1.7  2004/05/04 23:23:45  cignoni
00056 unified to the gl stlyle matix*vector. removed vector*matrix operator
00057 
00058 Revision 1.6  2004/03/25 14:57:49  ponchio
00059 Microerror. ($LOG$ -> $Log: not supported by cvs2svn $
00060 Microerror. ($LOG$ -> Revision 1.16  2008/02/22 17:40:27  ponchio
00061 Microerror. ($LOG$ -> Fixed determinantt problem and quaternion problem.
00062 Microerror. ($LOG$ ->
00063 Microerror. ($LOG$ -> Revision 1.15  2008/02/21 11:34:08  ponchio
00064 Microerror. ($LOG$ -> refixed bug in FromMatrix
00065 Microerror. ($LOG$ ->
00066 Microerror. ($LOG$ -> Revision 1.14  2008/02/21 10:57:59  ponchio
00067 Microerror. ($LOG$ -> fixed bug in FromMatrix
00068 Microerror. ($LOG$ ->
00069 Microerror. ($LOG$ -> Revision 1.13  2008/02/21 10:30:18  benedetti
00070 Microerror. ($LOG$ -> corrected bug in FromMatrix
00071 Microerror. ($LOG$ ->
00072 Microerror. ($LOG$ -> Revision 1.12  2007/02/05 14:17:48  corsini
00073 Microerror. ($LOG$ -> add new ctor (build similarity from euler angles)
00074 Microerror. ($LOG$ ->
00075 Microerror. ($LOG$ -> Revision 1.11  2004/12/15 18:45:50  tommyfranken
00076 Microerror. ($LOG$ -> *** empty log message ***
00077 Microerror. ($LOG$ ->
00078 Microerror. ($LOG$ -> Revision 1.10  2004/10/07 13:55:47  ganovelli
00079 Microerror. ($LOG$ -> templated on the kind of class used to implement rotation
00080 Microerror. ($LOG$ -> (default is QUternion but it can be Matrix44 as well)
00081 Microerror. ($LOG$ ->
00082 Microerror. ($LOG$ -> Revision 1.9  2004/06/04 13:35:07  cignoni
00083 Microerror. ($LOG$ -> added InverseMatrix,
00084 Microerror. ($LOG$ ->
00085 Microerror. ($LOG$ -> Revision 1.8  2004/05/07 10:09:13  cignoni
00086 Microerror. ($LOG$ -> missing final newline
00087 Microerror. ($LOG$ ->
00088 Microerror. ($LOG$ -> Revision 1.7  2004/05/04 23:23:45  cignoni
00089 Microerror. ($LOG$ -> unified to the gl stlyle matix*vector. removed vector*matrix operator
00090 Microerror. ($LOG$ ->
00091 
00092 
00093 ****************************************************************************/
00094 
00095 #ifndef SIMILARITY_H
00096 #define SIMILARITY_H
00097 
00098 #include <vcg/math/quaternion.h>
00099 #include <vcg/math/matrix44.h>
00100 
00101 namespace vcg {
00102 
00103 template <class S,class RotationType = Quaternion<S> > class Similarity {
00104 public:
00105   Similarity() {}
00106   Similarity(const RotationType &q) { SetRotate(q); }
00107   Similarity(const Point3<S> &p) { SetTranslate(p); }
00108   Similarity(S s) { SetScale(s); }
00109         Similarity(S alpha, S beta, S gamma)
00110         {
00111                 rot.FromEulerAngles(alpha, beta, gamma);
00112                 tra = Point3<S>(0, 0, 0);
00113                 sca = 1;
00114         }
00115   
00116   Similarity operator*(const Similarity &affine) const;
00117   Similarity &operator*=(const Similarity &affine);
00118   //Point3<S> operator*(const Point3<S> &p) const;
00119   
00120   
00121   Similarity &SetIdentity();
00122   Similarity &SetScale(const S s);
00123         Similarity &SetTranslate(const Point3<S> &t);   
00125   Similarity &SetRotate(S angle, const Point3<S> & axis); 
00126   Similarity &SetRotate(const RotationType &q);
00127 
00128   Matrix44<S> Matrix() const;
00129   Matrix44<S> InverseMatrix() const;
00130   void FromMatrix(const Matrix44<S> &m);
00131 
00132   RotationType rot;
00133   Point3<S> tra;
00134   S sca;  
00135 };
00136 
00137 template <class S,class RotationType> Similarity<S,RotationType> &Invert(Similarity<S,RotationType> &m);
00138 template <class S,class RotationType> Similarity<S,RotationType> Inverse(const Similarity<S,RotationType> &m);
00139 template <class S,class RotationType> Point3<S> operator*(const Similarity<S,RotationType> &m, const Point3<S> &p);
00140 
00141 
00142 template <class S,class RotationType> Similarity<S,RotationType> Similarity<S,RotationType>::operator*(const Similarity &a) const {
00143   Similarity<S,RotationType> r;
00144   r.rot = rot * a.rot;
00145   r.sca = sca * a.sca;
00146   r.tra = (rot.Rotate(a.tra)) * sca + tra;
00147   return r;
00148 }
00149 
00150 template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::operator*=(const Similarity &a) {  
00151   rot = rot * a.rot;
00152   sca = sca * a.sca;
00153   tra = (rot.Rotate(a.tra)) * sca + tra;
00154   return *this;
00155 }
00156   
00157 template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetIdentity() {
00158   rot.SetIdentity();
00159   tra = Point3<S>(0, 0, 0);
00160   sca = 1;
00161   return *this;
00162 }
00163 
00164 template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetScale(const S s) {
00165   SetIdentity();
00166   sca = s;
00167   return *this;
00168 }
00169 
00170 template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetTranslate(const Point3<S> &t) {
00171   SetIdentity();
00172   tra = t;
00173   return *this;
00174 }
00175 
00176 template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetRotate(S angle, const Point3<S> &axis) {
00177   SetIdentity();
00178   rot.FromAxis(angle, axis);
00179   return *this;
00180 }
00181 
00182 template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetRotate(const RotationType &q) {
00183   SetIdentity();
00184   rot = q;  
00185   return *this;
00186 }
00187 
00188 
00189 template <class S,class RotationType> Matrix44<S> Similarity<S,RotationType>::Matrix() const {
00190   Matrix44<S> r;
00191   rot.ToMatrix(r);
00192   Matrix44<S> s = Matrix44<S>().SetScale(sca, sca, sca);
00193   Matrix44<S> t = Matrix44<S>().SetTranslate(tra[0], tra[1], tra[2]);
00194   return Matrix44<S>(s*r*t);  // trans * scale * rot;
00195 }
00196 
00197 template <class S,class RotationType> Matrix44<S> Similarity<S,RotationType>::InverseMatrix() const {
00198   return Inverse(Matrix());
00199 }
00200 
00201 
00202 template <class S,class RotationType> void Similarity<S,RotationType>::FromMatrix(const Matrix44<S> &m) {
00203  //Computes a t*s*r decomposition
00204   S det = m.Determinant();
00205   assert(det > 0);
00206   sca = (S)pow((S)det, (S)(1/3.0));  
00207   Matrix44<S> t = m*Matrix44<S>().SetScale(1/sca, 1/sca, 1/sca);
00208   tra[0] = t.ElementAt(0, 3);t[0][3] = 0.0;
00209   tra[1] = t.ElementAt(1, 3);t[1][3] = 0.0;
00210   tra[2] = t.ElementAt(2, 3);t[2][3] = 0.0;
00211   rot.FromMatrix(t);
00212 
00213         Invert(t);      
00214         tra = t * tra;
00215         tra/= sca;
00216 }
00217 
00218 
00219 template <class S,class RotationType> Similarity<S,RotationType> &Invert(Similarity<S,RotationType> &a) {  
00220   a.rot.Invert();
00221   a.sca = 1/a.sca;
00222   a.tra = a.rot.Rotate(-a.tra)*a.sca;
00223   return a;
00224 }
00225 
00226 template <class S,class RotationType> Similarity<S,RotationType> Inverse(const Similarity<S,RotationType> &m) {
00227   Similarity<S,RotationType> a = m;
00228   return Invert(a);
00229 }
00230 
00231 
00232 template <class S,class RotationType> Similarity<S,RotationType> Interpolate(const Similarity<S,RotationType> &a, const Similarity<S,RotationType> &b, const S t) {
00233   Similarity<S,RotationType> r;
00234   r.rot = interpolate(a.rot, b.rot, t);
00235   r.tra = t * a.tra + (1-t) * b.tra;
00236   r.sca = t * a.sca + (1-t) * b.sca;
00237   return r;
00238 }
00239 
00240 template <class S,class RotationType> Point3<S> operator*(const Similarity<S,RotationType> &m, const Point3<S> &p) {
00241   Matrix44<S> t;
00242   m.rot.ToMatrix(t);  
00243   Point3<S> r = t*p;
00244   r *= m.sca;
00245   r += m.tra;
00246   return r;
00247 }
00248 
00249 //typedef Similarity<float> Similarityf;
00250 //typedef Similarity<double>Similarityd;
00251 
00252 class Similarityf:public Similarity<float>{};
00253 
00254 class Similarityd:public Similarity<double>{};
00255 
00256 } //namespace
00257 
00258 #endif