vcglib/vcg/math/matrix.h

/****************************************************************************
* 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.                                                         *
*                                                                           *
****************************************************************************/

#ifndef VCG_USE_EIGEN
#include "deprecated_matrix.h"
#endif


#ifndef MATRIX_VCGLIB
#define MATRIX_VCGLIB

#include "eigen.h"
#include <vcg/space/point.h>

namespace vcg{
namespace ndim{
template<class Scalar> class Matrix;
}
}

namespace Eigen{
template<typename Scalar>
struct ei_traits<vcg::ndim::Matrix<Scalar> > : ei_traits<Eigen::Matrix<Scalar,Dynamic,Dynamic> > {};
}

namespace vcg{
namespace ndim{

/** \addtogroup math */
/* @{ */

/*!
 * This class represent a diagonal <I>m</I><EFBFBD><I>m</I> matrix.
 */
class MatrixDiagBase{public:
virtual const int & Dimension()const =0;
virtual const float operator[](const int & i) const = 0;
};

template<int N, class S>
class MatrixDiag: public Point<N,S>, public MatrixDiagBase{
public:
	const int & Dimension() const {return N;}
	MatrixDiag(const Point<N,S>&p):Point<N,S>(p){}
};

/*!
 * 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.
 */
template<class _Scalar>
class Matrix : public Eigen::Matrix<_Scalar,Eigen::Dynamic,Eigen::Dynamic> // FIXME col or row major ?
{

	typedef Eigen::Matrix<_Scalar,Eigen::Dynamic,Eigen::Dynamic> _Base;
	
public:

	_EIGEN_GENERIC_PUBLIC_INTERFACE(Matrix,_Base);
	typedef _Scalar ScalarType;

	VCG_EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Matrix)

	/*!
	*	Default constructor
	* All the elements are initialized to zero.
	*	\param m the number of matrix rows
	* \param n the number of matrix columns
	*/
	Matrix(unsigned int m, unsigned int n)
		: Base(m,n)
	{
		memset(Base::data(), 0, m*n*sizeof(Scalar));
	}

	/*!
	*	Constructor
	* The matrix elements are initialized with the values of the elements in \i values.
	*	\param m the number of matrix rows
	* \param n the number of matrix columns
	*	\param values the values of the matrix elements
	*/
	Matrix(unsigned int m, unsigned int n, Scalar *values)
		: Base(m.n)
	{
		*this = Eigen::Map<Eigen::Matrix<Scalar,Dynamic,Dynamic,RowMajor> >(values, m , n);
	}

	/*!
	*	Empty constructor
	*   Just create the object
	*/
	Matrix() : Base() {}

	/*!
	*	Copy constructor
	*	The matrix elements are initialized with the value of the corresponding element in \i m
	* \param m the matrix to be copied
	*/
	Matrix(const Matrix<Scalar> &m) : Base(m) {}

	template<typename OtherDerived>
	Matrix(const Eigen::MatrixBase<OtherDerived> &m) : Base(m) {}

	/*!
	*	Default destructor
	*/
	~Matrix() {}

	/*!
	* \deprecated use *this.row(i)
	*	Subscript operator:
	* \param i	the index of the row
	*	\return a reference to the <I>i</I>-th matrix row
	*/
	inline typename Base::RowXpr operator[](const unsigned int i)
	{ return Base::row(i); }

	/*!
	* \deprecated use *this.row(i)
	*	Const subscript operator
	* \param i	the index of the row
	*	\return a reference to the <I>i</I>-th matrix row
	*/
	inline const typename Base::RowXpr operator[](const unsigned int i) const
	{ return Base::row(i); }


	/*!
	*	Matrix multiplication: calculates the cross product.
	*	\param	reference to the matrix to multiply by
	*	\return the matrix product
	*/
	/*template <int N,int M>
	void DotProduct(Point<N,Scalar> &m,Point<M,Scalar> &result)
	{
		unsigned int i, j,  p,  r;
		for (i=0, p=0, r=0; i<M; i++)
		{ result[i]=0;
			for (j=0; j<N; j++)
				result[i]+=(*this)[i][j]*m[j];
		}
	};*/

	/*!
	* \deprecated use *this.resize()
	*	Resize the current matrix.
	*	\param m the number of matrix rows.
	* \param n the number of matrix columns.
	*/
	void Resize(const unsigned int m, const unsigned int n)
	{
		assert(m>=2);
		assert(n>=2);
		Base::resize(m,n);
		memset(Base::data(), 0, m*n*sizeof(Scalar));
	};

// 	EIGEN_DEPRECATED void Transpose()
// 	{
// 		assert(0 && "dangerous use of deprecated Transpose function, please use: m = m.transpose();");
// 	}
};

typedef vcg::ndim::Matrix<double> MatrixMNd;
typedef vcg::ndim::Matrix<float>  MatrixMNf;

/*! @} */

template <class MatrixType>
void Invert(MatrixType & m)
{
	m = m.inverse();
}

}
} // end of namespace

#endif