* change all remaining Transpose to transpose,

* update the gl/math wrappers to make them more Eigen friendly
  (and remove the useless, and not used, and somehow dangerous
   *Direct and *E functions)
* add automatic reinterpret_casting from Eigen::Matrix to vcg
  specialized types

apps/ptx2ply/ptx2ply.cpp

@@ -464,7 +464,7 @@ int readmesh(FILE* fp)
 		}
 	}
 
-	Transpose(currtrasf);
+	currtrasf = currtrasf.transpose().eval();
 
 	// apply tranformation
 	if(hascolor && savecolor)

apps/test/quaternion/quat_test.cpp

@@ -74,8 +74,7 @@ bool verify(Matrix33f &m) {
   cout << "Column norms: " << m.GetColumn(0).Norm() << " "
                         << m.GetColumn(1).Norm() << " "
                         << m.GetColumn(2).Norm() << endl;
-  Matrix33f im = m;
+  Matrix33f im = m.transpose() * m;
-  im.Transpose();
   im = im*m;
   cout << "Check ortonormality: " <<  im << endl;
   Quaternionf q;

vcg/math/deprecated_matrix44.h

@@ -107,6 +107,7 @@ Revision 1.12  2004/03/25 14:57:49  ponchio
 #include <vcg/space/point3.h>
 #include <vcg/space/point4.h>
 #include <vector>
+#include <iostream>
 
 
 namespace vcg {
@@ -291,6 +292,18 @@ public:
 	// for the transistion to eigen
 	const Matrix44& eval() { return *this; }
 
+	void print() {
+				unsigned int i, j, p;
+				for (i=0, p=0; i<4; i++, p+=4)
+				{
+					std::cout << "[\t";
+					for (j=0; j<4; j++)
+						std::cout << _a[p+j] << "\t";
+
+					std::cout << "]\n";
+				}
+				std::cout << "\n";
+	}
 
 };
 

vcg/math/eigen.h

@@ -31,7 +31,24 @@
 
 // forward declarations
 namespace Eigen {
+
+#include "../Eigen/src/Core/util/Meta.h"
+
 template<typename Derived1, typename Derived2, int Size> struct ei_lexi_comparison;
+
+template<typename Derived1, typename Derived2,
+	bool SameType = ei_is_same_type<Derived1,Derived2>::ret,
+	bool SameSize = Derived1::SizeAtCompileTime==Derived2::SizeAtCompileTime>
+struct ei_import_selector;
+
+template<typename XprType,
+	int Rows = XprType::RowsAtCompileTime,
+	int Cols = XprType::ColsAtCompileTime,
+	int StorageOrder = XprType::Flags&1,
+	int MRows = XprType::MaxRowsAtCompileTime,
+	int MCols = XprType::MaxColsAtCompileTime>
+struct ei_to_vcgtype;
+
 }
 
 #include "base.h"
@@ -156,6 +173,46 @@ template<typename Derived1, typename Derived2> struct ei_lexi_comparison<Derived
 	}
 };
 
+// implementation of Import
+template<typename Derived1, typename Derived2>
+struct ei_import_selector<Derived1,Derived2,true,true>
+{
+	static void run(Derived1& a, const Derived2& b) { a = b; }
+};
+
+template<typename Derived1, typename Derived2>
+struct ei_import_selector<Derived1,Derived2,false,true>
+{
+	static void run(Derived1& a, const Derived2& b)
+	{ a = b.template cast<typename Derived1::Scalar>(); }
+};
+
+template<typename Derived1, typename Derived2>
+struct ei_import_selector<Derived1,Derived2,false,false>
+{
+	static void run(Derived1& a, const Derived2& b)
+	{
+		EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived1);
+		EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived1);
+		EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived2);
+		EIGEN_STATIC_ASSERT_FIXED_SIZE(Derived2);
+		enum {
+			Size1 = Derived1::SizeAtCompileTime,
+			Size2 = Derived2::SizeAtCompileTime
+		};
+		assert(Size1<=4 && Size2<=4);
+		a.coeffRef(0) = Scalar(b.coeff(0));
+		if (Size1>1) { if (Size2>1) a.coeffRef(1) = Scalar(b.coeff(1)); else a.coeffRef(1) = 0; }
+		if (Size1>2) { if (Size2>2) a.coeffRef(2) = Scalar(b.coeff(2)); else a.coeffRef(2) = 0; }
+		if (Size1>3) { if (Size2>3) a.coeffRef(3) = Scalar(b.coeff(3)); else a.coeffRef(3) = 0; }
+	}
+};
+
+// default implementation of ei_to_vcgtype
+// the specialization are with
+template<typename XprType,int Rows,int Cols,int StorageOrder,int MRows,int MCols>
+struct ei_to_vcgtype { typedef Matrix<typename XprType::Scalar,Rows,Cols,StorageOrder,MRows,MCols> type; };
+
 }
 
 #define VCG_EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \

vcg/math/eigen_matrix_addons.h

@@ -24,28 +24,31 @@
 #warning You are including deprecated math stuff
 
 enum {Dimension = SizeAtCompileTime};
+typedef typename ei_to_vcgtype<Matrix>::type EquivVcgType;
 typedef vcg::VoidType   ParamType;
 typedef Matrix          PointType;
 using Base::V;
 
+// automatic conversion to similar vcg types
+// the otherway round is implicit because they inherits this Matrix tyoe
+operator EquivVcgType& () { return *reinterpret_cast<EquivVcgType*>(this); }
+operator const EquivVcgType& () const { return *reinterpret_cast<const EquivVcgType*>(this); }
+
+/** \deprecated use m.cast<NewScalar>() */
 /// importer for points with different scalar type and-or dimensionality
 // FIXME the Point3/Point4 specialization were only for same sizes ??
 // while the Point version was generic like this one
 template<typename OtherDerived>
 inline void Import(const MatrixBase<OtherDerived>& b)
 {
-	EIGEN_STATIC_ASSERT_VECTOR_ONLY(Matrix);
+	ei_import_selector<Matrix,OtherDerived>::run(*this,b.derived());
-	EIGEN_STATIC_ASSERT_FIXED_SIZE(Matrix);
-	EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived);
-	EIGEN_STATIC_ASSERT_FIXED_SIZE(OtherDerived);
-	enum { OtherSize = OtherDerived::SizeAtCompileTime };
-	assert(SizeAtCompileTime<=4 && OtherSize<=4);
-	data()[0] = Scalar(b[0]);
-	if (SizeAtCompileTime>1) { if (OtherSize>1) data()[1] = Scalar(b[1]); else data()[1] = 0; }
-	if (SizeAtCompileTime>2) { if (OtherSize>2) data()[2] = Scalar(b[2]); else data()[2] = 0; }
-	if (SizeAtCompileTime>3) { if (OtherSize>3) data()[3] = Scalar(b[3]); else data()[3] = 0; }
 }
 
+/// constructor for points with different scalar type and-or dimensionality
+template<typename OtherDerived>
+static inline Matrix Construct(const MatrixBase<OtherDerived>& b)
+{ Matrix p; p.Import(b); return p; }
+
 /// importer for homogeneous points
 template<typename OtherDerived>
 inline void ImportHomo(const MatrixBase<OtherDerived>& b)
@@ -58,21 +61,10 @@ inline void ImportHomo(const MatrixBase<OtherDerived>& b)
 	data()[SizeAtCompileTime-1] = Scalar(1.0);
 }
 
-/// constructor for points with different scalar type and-or dimensionality
+/// constructor for homogeneus point.
-template<typename OtherDerived>
-static inline Matrix Construct(const MatrixBase<OtherDerived>& b)
-{
-	Matrix p; p.Import(b);
-	return p;
-}
-
-	/// constructor for homogeneus point.
 template<typename OtherDerived>
 static inline Matrix ConstructHomo(const MatrixBase<OtherDerived>& b)
-{
+{ Matrix p; p.ImportHomo(b); return p; }
-	Matrix p; p.ImportHomo(b);
-	return p;
-}
 
 inline const Scalar &X() const { return data()[0]; }
 inline const Scalar &Y() const { return data()[1]; }
@@ -81,15 +73,19 @@ inline Scalar &X() { return data()[0]; }
 inline Scalar &Y() { return data()[1]; }
 inline Scalar &Z() { assert(SizeAtCompileTime>2); return data()[2]; }
 
-// note, W always returns the last entry
+/** note, W always returns the last entry */
 inline Scalar& W() { return data()[SizeAtCompileTime-1]; }
+/** note, W always returns the last entry */
 inline const Scalar& W() const { return data()[SizeAtCompileTime-1]; }
 
-Scalar* V() { return data(); }
+/** \deprecated use .data() */
-const Scalar* V() const { return data(); }
+EIGEN_DEPRECATED Scalar* V() { return data(); }
+/** \deprecated use .data() */
+EIGEN_DEPRECATED const Scalar* V() const { return data(); }
 
+/** \deprecated use m.coeff(i) or m[i] or m(i) */
 // overloaded to return a const reference
-inline const Scalar& V( const int i ) const
+EIGEN_DEPRECATED inline const Scalar& V( const int i ) const
 {
 	assert(i>=0 && i<SizeAtCompileTime);
 	return data()[i];

vcg/math/matrix.h

@@ -41,6 +41,8 @@ template<class Scalar> class Matrix;
 namespace Eigen{
 template<typename Scalar>
 struct ei_traits<vcg::ndim::Matrix<Scalar> > : ei_traits<Eigen::Matrix<Scalar,Dynamic,Dynamic> > {};
+template<typename XprType> struct ei_to_vcgtype<XprType,Dynamic,Dynamic,RowMajor,Dynamic,Dynamic>
+{ typedef vcg::ndim::Matrix<typename XprType::Scalar> type; };
 }
 
 namespace vcg{
@@ -50,7 +52,7 @@ namespace ndim{
 /* @{ */
 
 /*!
- * \deprecated use Matrix<Scalar,Rows,Cols> or Matrix<Scalar,Dynamic,Dynamic>
+ * \deprecated use Matrix<Scalar,Rows,Cols> or Matrix<Scalar,Dynamic,Dynamic> or any typedef
  * This class represent a generic <I>m</I><EFBFBD><I>n</I> matrix. The class is templated over the scalar type field.
  * @param Scalar (Templete Parameter) Specifies the ScalarType field.
  */
@@ -63,7 +65,6 @@ public:
 
 	_EIGEN_GENERIC_PUBLIC_INTERFACE(Matrix,_Base);
 	typedef _Scalar ScalarType;
-
 	VCG_EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Matrix)
 
 	/*!

vcg/math/matrix33.h

@@ -38,12 +38,14 @@ template<class Scalar> class Matrix33;
 namespace Eigen{
 template<typename Scalar>
 struct ei_traits<vcg::Matrix33<Scalar> > : ei_traits<Eigen::Matrix<Scalar,3,3,RowMajor> > {};
+template<typename XprType> struct ei_to_vcgtype<XprType,3,3,RowMajor,3,3>
+{ typedef vcg::Matrix33<typename XprType::Scalar> type; };
 }
 
 namespace vcg {
 
-
+/** \deprecated use Matrix<Scalar,3,3>
-/** @name Matrix33
+	@name Matrix33
 	Class Matrix33.
     This is the class for definition of a matrix 3x3.
 	@param S (Templete Parameter) Specifies the ScalarType field.
@@ -98,7 +100,6 @@ public:
 		return SetRotateRad(math::ToRad(angle),axis);
 	}
 
-
   // Warning, this Inversion code can be HIGHLY NUMERICALLY UNSTABLE!
   // In most case you are advised to use the Invert() method based on SVD decomposition.
   /** \deprecated */
@@ -110,18 +111,13 @@ public:
 		    printf("| %g \t%g \t%g |\n",coeff(i,0),coeff(i,1),coeff(i,2));
 	}
 
-	/*
+	/** \deprecated use a * b.transpose()
 	compute the matrix generated by the product of a * b^T
 	*/
-	void ExternalProduct(const Point3<Scalar> &a, const Point3<Scalar> &b)
+	// hm.... this is the outer product
-	{
+	void ExternalProduct(const Point3<Scalar> &a, const Point3<Scalar> &b) { *this = a * b.transpose(); }
-		for(int i=0;i<3;++i)
-			for(int j=0;j<3;++j)
-				(*this)[i][j] = a[i]*b[j];
-	}
 
-	/* Compute the Frobenius Norm of the Matrix
+	/** Compute the Frobenius Norm of the Matrix */
-	*/
 	Scalar Norm() { return Base::cwise().abs2().sum(); }
 // 	{
 // 		// FIXME looks like there was a bug: j is not used !!!

vcg/math/matrix44.h

@@ -41,6 +41,8 @@ template<class Scalar> class Matrix44;
 namespace Eigen{
 template<typename Scalar>
 struct ei_traits<vcg::Matrix44<Scalar> > : ei_traits<Eigen::Matrix<Scalar,4,4,RowMajor> > {};
+template<typename XprType> struct ei_to_vcgtype<XprType,4,4,RowMajor,4,4>
+{ typedef vcg::Matrix44<typename XprType::Scalar> type; };
 }
 
 namespace vcg {
@@ -140,17 +142,6 @@ public:
 	Matrix44 &SetRotateDeg(Scalar AngleDeg, const Point3<Scalar> & axis);
 	Matrix44 &SetRotateRad(Scalar AngleRad, const Point3<Scalar> & axis);
 
-	template <class Q> void Import(const Matrix44<Q> &m) {
-		for(int i = 0; i < 16; i++)
-			Base::data()[i] = (Scalar)(m.data()[i]);
-	}
-		template <class Q>
-	static inline Matrix44 Construct( const Matrix44<Q> & b )
-	{
-		Matrix44 tmp; tmp.FromMatrix(b);
-		return tmp;
-	}
-
 // 	template <class T> Point3<T> operator*(const Point3<T> &p) {
 // 		T w;
 // 		Point3<T> s;
@@ -173,30 +164,10 @@ public:
 		return s;
 	}
 
+	void print() {std::cout << *this << "\n\n";}
+
 };
 
-
-/** Class for solving A * x = b. */
-template <class T> class LinearSolve: public Matrix44<T> {
-public:
-	LinearSolve(const Matrix44<T> &m);
-	Point4<T> Solve(const Point4<T> &b); // solve A <20> x = b
-	///If you need to solve some equation you can use this function instead of Matrix44 one for speed.
-	T Determinant() const;
-protected:
-	///Holds row permutation.
-	int index[4]; //hold permutation
-	///Hold sign of row permutation (used for determinant sign)
-	T d;
-	bool Decompose();
-};
-
-/*** Postmultiply */
-//template <class T> Point3<T> operator*(const Point3<T> &p, const Matrix44<T> &m);
-
-///Premultiply
-// template <class T> Point3<T> operator*(const Matrix44<T> &m, const Point3<T> &p);
-
 //return NULL matrix if not invertible
 template <class T> Matrix44<T> &Invert(Matrix44<T> &m);
 template <class T> Matrix44<T> Inverse(const Matrix44<T> &m);
@@ -206,18 +177,6 @@ typedef Matrix44<int>    Matrix44i;
 typedef Matrix44<float>  Matrix44f;
 typedef Matrix44<double> Matrix44d;
 
-
-//template <class T> T &Matrix44<T>::operator[](const int i) {
-//  assert(i >= 0 && i < 16);
-//  return ((T *)_a)[i];
-//}
-//
-//template <class T> const T &Matrix44<T>::operator[](const int i) const {
-//  assert(i >= 0 && i < 16);
-//  return ((T *)_a)[i];
-//}
-
-
 template < class PointType , class T > void operator*=( std::vector<PointType> &vert, const Matrix44<T> & m ) {
 	typename std::vector<PointType>::iterator ii;
 	for(ii=vert.begin();ii!=vert.end();++ii)
@@ -487,22 +446,6 @@ bool Decompose(Matrix44<T> &M, Point3<T> &ScaleV, Point3<T> &ShearV, Point3<T> &
 	return true;
 }
 
-
-
-
-
-// template <class T> Point3<T> operator*(const Point3<T> &p, const Matrix44<T> &m) {
-//  T w;
-//  Point3<T> s;
-//  s[0] = m.ElementAt(0, 0)*p[0] + m.ElementAt(1, 0)*p[1] + m.ElementAt(2, 0)*p[2] + m.ElementAt(3, 0);
-//  s[1] = m.ElementAt(0, 1)*p[0] + m.ElementAt(1, 1)*p[1] + m.ElementAt(2, 1)*p[2] + m.ElementAt(3, 1);
-//  s[2] = m.ElementAt(0, 2)*p[0] + m.ElementAt(1, 2)*p[1] + m.ElementAt(2, 2)*p[2] + m.ElementAt(3, 2);
-//  w    = m.ElementAt(0, 3)*p[0] + m.ElementAt(1, 3)*p[1] + m.ElementAt(2, 3)*p[2] + m.ElementAt(3, 3);
-// 	if(w != 0) s /= w;
-//  return s;
-// }
-
-
 /*
 To invert a matrix you can
 either invert the matrix inplace calling

vcg/math/shot.h

@@ -205,8 +205,7 @@ public:
 		Matrix44<S> GetExtrinsicsToWorldMatrix() const {
 				Matrix44<S> rotM ;
 				Extrinsics.rot.ToMatrix(rotM);
-				Transpose(rotM);
+				return Matrix44<S>().SetTranslate(Extrinsics.tra) * rotM.transpose();
-				return Matrix44<S>().SetTranslate(Extrinsics.tra) * rotM;
 		}
 
 	/* Returns the matrix M such that
@@ -316,8 +315,7 @@ vcg::Point3<S> Shot<S,RotationType>::ConvertCameraToWorldCoordinates(const vcg::
 	vcg::Point3<S> cp = p;
 	cp[2]=-cp[2];	// note: World reference system is left handed
 	Extrinsics.rot.ToMatrix(rotM);
-  Transpose(rotM);
+	cp = rotM.transpose() * cp + GetViewPoint();
-	cp = rotM * cp+ GetViewPoint();
 	return cp;
 }
 

vcg/space/point2.h

@@ -37,6 +37,8 @@ template<typename Scalar> class Point2;
 
 namespace Eigen {
 template<typename Scalar> struct ei_traits<vcg::Point2<Scalar> > : ei_traits<Eigen::Matrix<Scalar,2,1> > {};
+template<typename XprType> struct ei_to_vcgtype<XprType,2,1,0,2,1>
+{ typedef vcg::Point2<typename XprType::Scalar> type; };
 }
 
 namespace vcg {

vcg/space/point3.h

@@ -38,6 +38,9 @@ namespace Eigen{
 
 template<typename Scalar> struct ei_traits<vcg::Point3<Scalar> > : ei_traits<Eigen::Matrix<Scalar,3,1> > {};
 
+template<typename XprType> struct ei_to_vcgtype<XprType,3,1,0,3,1>
+{ typedef vcg::Point3<typename XprType::Scalar> type; };
+
 template<typename Scalar>
 struct NumTraits<vcg::Point3<Scalar> > : NumTraits<Scalar>
 {

vcg/space/point4.h

@@ -36,6 +36,8 @@ template<typename Scalar> class Point4;
 
 namespace Eigen {
 template<typename Scalar> struct ei_traits<vcg::Point4<Scalar> > : ei_traits<Eigen::Matrix<Scalar,4,1> > {};
+template<typename XprType> struct ei_to_vcgtype<XprType,4,1,0,4,1>
+{ typedef vcg::Point4<typename XprType::Scalar> type; };
 }
 
 namespace vcg {

wrap/gl/deprecated_math.h

@@ -0,0 +1,144 @@
+/****************************************************************************
+* VCGLib                                                            o o     *
+* Visual and Computer Graphics Library                            o     o   *
+*                                                                _   O  _   *
+* Copyright(C) 2004                                                \/)\/    *
+* Visual Computing Lab                                            /\/|      *
+* ISTI - Italian National Research Council                           |      *
+*                                                                    \      *
+* All rights reserved.                                                      *
+*                                                                           *
+* This program is free software; you can redistribute it and/or modify      *   
+* it under the terms of the GNU General Public License as published by      *
+* the Free Software Foundation; either version 2 of the License, or         *
+* (at your option) any later version.                                       *
+*                                                                           *
+* This program is distributed in the hope that it will be useful,           *
+* but WITHOUT ANY WARRANTY; without even the implied warranty of            *
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
+* GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
+* for more details.                                                         *
+*                                                                           *
+****************************************************************************/
+/****************************************************************************
+  History
+
+$Log: not supported by cvs2svn $
+Revision 1.10  2006/02/13 13:05:05  cignoni
+Removed glew inclusion
+
+Revision 1.9  2004/09/30 00:48:07  ponchio
+<gl/glew.h> -> <GL/glew.h>
+
+Revision 1.8  2004/09/28 14:04:36  ganovelli
+glGet added
+
+Revision 1.7  2004/07/13 15:55:57  cignoni
+Added test on presence of glTranspose extension (for old hw support)
+
+Revision 1.6  2004/05/26 15:12:39  cignoni
+Removed inclusion of gl extension stuff
+
+Revision 1.5  2004/05/12 20:54:55  ponchio
+*** empty log message ***
+
+Revision 1.4  2004/05/12 13:07:47  ponchio
+Added #include <glew.h>
+
+Revision 1.3  2004/05/04 23:36:23  cignoni
+remove include of gl and added glextgension exploiting,
+
+Revision 1.2  2004/04/07 10:47:03  cignoni
+inlined functions for avoid multiple linking errors
+
+Revision 1.1  2004/03/31 15:27:17  ponchio
+*** empty log message ***
+
+
+****************************************************************************/
+
+#ifndef VCG_GL_MATH_H
+#define VCG_GL_MATH_H
+
+// Please note that this file assume that you have already included your 
+// gl-extension wrapping utility, and that therefore all the extension symbol are already defined.
+
+#include <vcg/math/matrix44.h>
+#include <vcg/math/similarity.h>
+//#include <GL/glew.h> // please do not include it!
+
+
+namespace vcg {
+
+inline void glMultMatrixE(const Matrix44f &matrix) {
+  //glMultMatrixf((const GLfloat *)(matrix[0]));  
+  if(glMultTransposeMatrixf) glMultTransposeMatrixf((const GLfloat *)(matrix.V())); 
+  else  {
+    glMultMatrixf((const GLfloat *)(matrix.transpose().eval().V()));
+  }
+}
+
+inline void glMultMatrix(const Matrix44f &matrix) {
+    glMultMatrixf((const GLfloat *)(matrix.transpose().eval().V()));
+}
+
+inline void glMultMatrixE(const Matrix44d &matrix) {
+  if(glMultTransposeMatrixd) glMultTransposeMatrixd((const GLdouble *)(matrix.V())); 
+  else  {
+    glMultMatrixd((const GLdouble *)(matrix.transpose().eval().V()));
+  }
+}
+inline void glMultMatrix(const Matrix44d &matrix) {
+    glMultMatrixd((const GLdouble *)(matrix.transpose().eval().V()));
+}
+
+inline void glMultMatrixDirect(const Matrix44f &matrix) {
+   glMultMatrixf((const GLfloat *)(matrix.V()));
+}
+
+inline void glMultMatrixDirect(const Matrix44d &matrix) {
+   glMultMatrixd((const GLdouble *)(matrix.V()));
+}
+
+inline void glMultMatrix(const Similarityf &s) {
+  glTranslatef(s.tra[0], s.tra[1], s.tra[2]);
+  glScalef(s.sca, s.sca, s.sca);
+  float alpha;
+  Point3f axis;
+  s.rot.ToAxis(alpha, axis);    
+  glRotatef(math::ToDeg(alpha), axis[0], axis[1], axis[2]);    
+  
+}
+
+inline void glMultMatrix(const Similarityd &s) {
+  glTranslated(s.tra[0], s.tra[1], s.tra[2]);
+  double alpha;
+  Point3d axis;
+  s.rot.ToAxis(alpha, axis);
+  glRotated(math::ToDeg(alpha), axis[0], axis[1], axis[2]);
+  glScaled(s.sca, s.sca, s.sca);
+}
+
+inline void glGetv(const GLenum  pname, Matrix44f  & m){
+	Matrix44f tmp;
+	glGetFloatv(pname,tmp.V());
+  m = tmp.transpose();
+}
+
+inline void glGetv(const GLenum  pname, Matrix44d  & m){
+  Matrix44d tmp;
+	glGetDoublev(pname,tmp.V());
+  m = tmp.transpose();
+}
+
+inline void glGetDirectv(const GLenum  pname, Matrix44f  & m){
+	glGetFloatv(pname,m.V());
+}
+
+inline void glGetDirecv(const GLenum  pname, Matrix44d  & m){
+	glGetDoublev(pname,m.V());
+}
+
+
+}//namespace
+#endif

wrap/gl/math.h

@@ -57,6 +57,10 @@ Revision 1.1  2004/03/31 15:27:17  ponchio
 
 ****************************************************************************/
 
+#ifndef VCG_USE_EIGEN
+#include "deprecated_math.h"
+#else
+
 #ifndef VCG_GL_MATH_H
 #define VCG_GL_MATH_H
 
@@ -70,35 +74,33 @@ Revision 1.1  2004/03/31 15:27:17  ponchio
 
 namespace vcg {
 
-inline void glMultMatrixE(const Matrix44f &matrix) {
+inline void glLoadMatrix(const Eigen::Matrix<float,4,4>& matrix) { glLoadMatrixf(matrix.data()); }
-  //glMultMatrixf((const GLfloat *)(matrix[0]));  
+inline void glLoadMatrix(const Eigen::Matrix<float,4,4,Eigen::RowMajor>& matrix) {
-  if(glMultTransposeMatrixf) glMultTransposeMatrixf((const GLfloat *)(matrix.V())); 
+	Eigen::Matrix4f tmp(matrix);
-  else  {
+	glLoadMatrixf(tmp.data());
-    glMultMatrixf((const GLfloat *)(matrix.transpose().eval().V()));
-  }
 }
+inline void glLoadMatrix(const Eigen::Matrix<double,4,4>& matrix) { glLoadMatrixd(matrix.data()); }
+inline void glLoadMatrix(const Eigen::Matrix<double,4,4,Eigen::RowMajor>& matrix) {
+	Eigen::Matrix4d tmp(matrix);
+	glLoadMatrixd(tmp.data());
+}
+template<typename Scalar>
+inline void glLoadMatrix(const Eigen::Transform<Scalar,3>& t) { glLoadMatrix(t.matrix()); }
 
-inline void glMultMatrix(const Matrix44f &matrix) {
-    glMultMatrixf((const GLfloat *)(matrix.transpose().eval().V()));
-}
 
-inline void glMultMatrixE(const Matrix44d &matrix) {
+inline void glMultMatrix(const Eigen::Matrix<float,4,4>& matrix) { glMultMatrixf(matrix.data()); }
-  if(glMultTransposeMatrixd) glMultTransposeMatrixd((const GLdouble *)(matrix.V())); 
+inline void glMultMatrix(const Eigen::Matrix<float,4,4,Eigen::RowMajor>& matrix) {
-  else  {
+	Eigen::Matrix<float,4,4> tmp(matrix);
-    glMultMatrixd((const GLdouble *)(matrix.transpose().eval().V()));
+	glMultMatrixf(tmp.data());
-  }
 }
-inline void glMultMatrix(const Matrix44d &matrix) {
+inline void glMultMatrix(const Eigen::Matrix<double,4,4>& matrix) { glMultMatrixd(matrix.data()); }
-    glMultMatrixd((const GLdouble *)(matrix.transpose().eval().V()));
+inline void glMultMatrix(const Eigen::Matrix<double,4,4,Eigen::RowMajor>& matrix) {
+	Eigen::Matrix<double,4,4> tmp(matrix);
+	glMultMatrixd(tmp.data());
 }
+template<typename Scalar>
+inline void glMultMatrix(const Eigen::Transform<Scalar,3>& t) { glMultMatrix(t.matrix()); }
 
-inline void glMultMatrixDirect(const Matrix44f &matrix) {
-   glMultMatrixf((const GLfloat *)(matrix.V()));
-}
-
-inline void glMultMatrixDirect(const Matrix44d &matrix) {
-   glMultMatrixd((const GLdouble *)(matrix.V()));
-}
 
 inline void glMultMatrix(const Similarityf &s) {
   glTranslatef(s.tra[0], s.tra[1], s.tra[2]);
@@ -107,7 +109,6 @@ inline void glMultMatrix(const Similarityf &s) {
   Point3f axis;
   s.rot.ToAxis(alpha, axis);
   glRotatef(math::ToDeg(alpha), axis[0], axis[1], axis[2]);
-  
 }
 
 inline void glMultMatrix(const Similarityd &s) {
@@ -119,26 +120,27 @@ inline void glMultMatrix(const Similarityd &s) {
   glScaled(s.sca, s.sca, s.sca);
 }
 
-inline void glGetv(const GLenum  pname, Matrix44f  & m){
+inline void glGetv(const GLenum  pname, Eigen::Matrix<float,4,4>& matrix){
-	Matrix44f tmp;
+	glGetFloatv(pname,matrix.data());
-	glGetFloatv(pname,tmp.V());
-  m = tmp.transpose();
 }
-
+inline void glGetv(const GLenum pname, Eigen::Matrix<double,4,4>& matrix){
-inline void glGetv(const GLenum  pname, Matrix44d  & m){
+	glGetDoublev(pname,matrix.data());
-  Matrix44d tmp;
-	glGetDoublev(pname,tmp.V());
-  m = tmp.transpose();
 }
-
+inline void glGetv(const GLenum pname, Eigen::Matrix<float,4,4,Eigen::RowMajor>& matrix){
-inline void glGetDirectv(const GLenum  pname, Matrix44f  & m){
+	Eigen::Matrix4f tmp;
-	glGetFloatv(pname,m.V());
+	glGetFloatv(pname,tmp.data());
+	matrix = tmp;
 }
-
+inline void glGetv(const GLenum pname, Eigen::Matrix<double,4,4,Eigen::RowMajor>& matrix){
-inline void glGetDirecv(const GLenum  pname, Matrix44d  & m){
+	Eigen::Matrix4d tmp;
-	glGetDoublev(pname,m.V());
+	glGetDoublev(pname,tmp.data());
+	matrix = tmp;
 }
-
+template<typename Scalar>
+inline void glGetv(const GLenum pname, const Eigen::Transform<Scalar,3>& t)
+{ glGetv(pname,t.matrix()); }
 
 }//namespace
 #endif
+
+#endif

wrap/gui/trackball.cpp

@@ -177,7 +177,7 @@ void Trackball::DrawPostApply() {
 }
 
 void Trackball::Apply () {
-  glTranslate (center);
+  glTranslate (center);track.Matrix().print();
   glMultMatrix (track.Matrix());
   glTranslate (-center);
 }