From 5d07b02cf62aac4381c6ce2b3f0d9ff94cff21cc Mon Sep 17 00:00:00 2001
From: ganovelli <fabio.ganovelli@isti.cnr.it>
Date: Thu, 7 Oct 2004 13:55:47 +0000
Subject: [PATCH] templated on the kind of class used to implement rotation
 (default is QUternion but it can be Matrix44 as well)

---
 vcg/math/similarity.h | 64 +++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 27 deletions(-)

diff --git a/vcg/math/similarity.h b/vcg/math/similarity.h
index e5c6f478..47285e4c 100644
--- a/vcg/math/similarity.h
+++ b/vcg/math/similarity.h
@@ -24,6 +24,9 @@
   History
 
 $Log: not supported by cvs2svn $
+Revision 1.9  2004/06/04 13:35:07  cignoni
+added InverseMatrix,
+
 Revision 1.8  2004/05/07 10:09:13  cignoni
 missing final newline
 
@@ -32,6 +35,9 @@ unified to the gl stlyle matix*vector. removed vector*matrix operator
 
 Revision 1.6  2004/03/25 14:57:49  ponchio
 Microerror. ($LOG$ -> $Log: not supported by cvs2svn $
+Microerror. ($LOG$ -> Revision 1.9  2004/06/04 13:35:07  cignoni
+Microerror. ($LOG$ -> added InverseMatrix,
+Microerror. ($LOG$ ->
 Microerror. ($LOG$ -> Revision 1.8  2004/05/07 10:09:13  cignoni
 Microerror. ($LOG$ -> missing final newline
 Microerror. ($LOG$ ->
@@ -50,10 +56,10 @@ Microerror. ($LOG$ ->
 
 namespace vcg {
 
-template <class S> class Similarity {
+template <class S,class RotationType = Quaternion<S> > class Similarity {
 public:
   Similarity() {}
-  Similarity(const Quaternion<S> &q) { SetRotate(q); }
+  Similarity(const RotationType &q) { SetRotate(q); }
   Similarity(const Point3<S> &p) { SetTranslate(p); }
   Similarity(S s) { SetScale(s); }
   
@@ -67,70 +73,70 @@ public:
 	Similarity &SetTranslate(const Point3<S> &t);	
   ///use radiants for angle.
   Similarity &SetRotate(S angle, const Point3<S> & axis); 
-  Similarity &SetRotate(const Quaternion<S> &q);
+  Similarity &SetRotate(const RotationType &q);
 
   Matrix44<S> Matrix() const;
   Matrix44<S> InverseMatrix() const;
   void FromMatrix(const Matrix44<S> &m);
 
-  Quaternion<S> rot;
+  RotationType rot;
   Point3<S> tra;
   S sca;  
 };
 
-template <class S> Similarity<S> &Invert(Similarity<S> &m);
-template <class S> Similarity<S> Inverse(const Similarity<S> &m);
-template <class S> Point3<S> operator*(const Similarity<S> &m, const Point3<S> &p);
+template <class S,class RotationType> Similarity<S,RotationType> &Invert(Similarity<S,RotationType> &m);
+template <class S,class RotationType> Similarity<S,RotationType> Inverse(const Similarity<S,RotationType> &m);
+template <class S,class RotationType> Point3<S> operator*(const Similarity<S,RotationType> &m, const Point3<S> &p);
 
 
-template <class S> Similarity<S> Similarity<S>::operator*(const Similarity &a) const {
-  Similarity<S> r;
+template <class S,class RotationType> Similarity<S,RotationType> Similarity<S,RotationType>::operator*(const Similarity &a) const {
+  Similarity<S,RotationType> r;
   r.rot = rot * a.rot;
   r.sca = sca * a.sca;
   r.tra = (rot.Rotate(a.tra)) * sca + tra;
   return r;
 }
 
-template <class S> Similarity<S> &Similarity<S>::operator*=(const Similarity &a) {  
+template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::operator*=(const Similarity &a) {  
   rot = rot * a.rot;
   sca = sca * a.sca;
   tra = (rot.Rotate(a.tra)) * sca + tra;
   return *this;
 }
   
-template <class S> Similarity<S> &Similarity<S>::SetIdentity() {
-  rot.FromAxis(0, Point3<S>(1, 0, 0));
+template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetIdentity() {
+  rot.SetIdentity();
   tra = Point3<S>(0, 0, 0);
   sca = 1;
   return *this;
 }
 
-template <class S> Similarity<S> &Similarity<S>::SetScale(const S s) {
+template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetScale(const S s) {
   SetIdentity();
   sca = s;
   return *this;
 }
 
-template <class S> Similarity<S> &Similarity<S>::SetTranslate(const Point3<S> &t) {
+template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetTranslate(const Point3<S> &t) {
   SetIdentity();
   tra = t;
   return *this;
 }
 
-template <class S> Similarity<S> &Similarity<S>::SetRotate(S angle, const Point3<S> &axis) {
+template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetRotate(S angle, const Point3<S> &axis) {
   SetIdentity();
   rot.FromAxis(angle, axis);
   return *this;
 }
 
-template <class S> Similarity<S> &Similarity<S>::SetRotate(const Quaternion<S> &q) {
+template <class S,class RotationType> Similarity<S,RotationType> &Similarity<S,RotationType>::SetRotate(const RotationType &q) {
   SetIdentity();
   rot = q;  
   return *this;
 }
 
 
-template <class S> Matrix44<S> Similarity<S>::Matrix() const {
+template <class S,class RotationType> Matrix44<S> Similarity<S,RotationType>::Matrix() const {
   Matrix44<S> r;
   rot.ToMatrix(r);
   Matrix44<S> s = Matrix44<S>().SetScale(sca, sca, sca);
@@ -138,12 +144,12 @@ template <class S> Matrix44<S> Similarity<S>::Matrix() const {
   return s*r*t;  // scale * rot * trans
 }
 
-template <class S> Matrix44<S> Similarity<S>::InverseMatrix() const {
+template <class S,class RotationType> Matrix44<S> Similarity<S,RotationType>::InverseMatrix() const {
   return Inverse(Matrix());
 }
 
 
-template <class S> void Similarity<S>::FromMatrix(const Matrix44<S> &m) {
+template <class S,class RotationType> void Similarity<S,RotationType>::FromMatrix(const Matrix44<S> &m) {
   sca = (S)pow(m.Determinant(), 1/3);  
   assert(sca != 0);
   Matrix44<S> t = m * Matrix44<S>().SetScale(1/sca, 1/sca, 1/sca);
@@ -153,36 +159,40 @@ template <class S> void Similarity<S>::FromMatrix(const Matrix44<S> &m) {
   tra[2] = t.element(3, 2);
 }
 
-template <class S> Similarity<S> &Invert(Similarity<S> &a) {  
+template <class S,class RotationType> Similarity<S,RotationType> &Invert(Similarity<S,RotationType> &a) {  
   a.rot.Invert();
   a.sca = 1/a.sca;
   a.tra = a.rot.Rotate(-a.tra)*a.sca;
   return a;
 }
 
-template <class S> Similarity<S> Inverse(const Similarity<S> &m) {
-  Similarity<S> a = m;
+template <class S,class RotationType> Similarity<S,RotationType> Inverse(const Similarity<S,RotationType> &m) {
+  Similarity<S,RotationType> a = m;
   return Invert(a);
 }
 
 
-template <class S> Similarity<S> Interpolate(const Similarity<S> &a, const Similarity<S> &b, const S t) {
-  Similarity<S> r;
+template <class S,class RotationType> Similarity<S,RotationType> Interpolate(const Similarity<S,RotationType> &a, const Similarity<S,RotationType> &b, const S t) {
+  Similarity<S,RotationType> r;
   r.rot = interpolate(a.rot, b.rot, t);
   r.tra = t * a.tra + (1-t) * b.tra;
   r.sca = t * a.sca + (1-t) * b.sca;
   return r;
 }
 
-template <class S> Point3<S> operator*(const Similarity<S> &m, const Point3<S> &p) {
+template <class S,class RotationType> Point3<S> operator*(const Similarity<S,RotationType> &m, const Point3<S> &p) {
   Point3<S> r = m.rot.Rotate(p);
   r *= m.sca;
   r += m.tra;
   return r;
 }
 
-typedef Similarity<float> Similarityf;
-typedef Similarity<double>Similarityd;
+//typedef Similarity<float> Similarityf;
+//typedef Similarity<double>Similarityd;
+
+class Similarityf:public Similarity<float>{};
+
+class Similarityd:public Similarity<double>{};
 
 } //namespace