old_matrix.h

Go to the documentation of this file.

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

#else

#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> > {};
template<typename XprType> struct ei_to_vcgtype<XprType,Dynamic,Dynamic,RowMajor,Dynamic,Dynamic>
{ typedef vcg::ndim::Matrix<typename XprType::Scalar> type; };
}

namespace vcg{
namespace ndim{

/* @{ */

template<class _Scalar>
class Matrix : public Eigen::Matrix<_Scalar,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor> // FIXME col or row major ?
{
        typedef Eigen::Matrix<_Scalar,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor> _Base;

public:

        _EIGEN_GENERIC_PUBLIC_INTERFACE(Matrix,_Base);
        typedef _Scalar ScalarType;
        VCG_EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Matrix)

        
        Matrix(int m, int n)
                : Base(m,n)
        {
                memset(Base::data(), 0, m*n*sizeof(Scalar));
        }

        Matrix(int m, int n, Scalar *values)
                : Base(m,n)
        {
                *this = Eigen::Map<Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor> >(values, m , n);
        }

        Matrix() : Base() {}

        Matrix(const Matrix<Scalar> &m) : Base(m) {}

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

        ~Matrix() {}

        inline typename Base::RowXpr operator[](const unsigned int i)
        { return Base::row(i); }

        inline const typename Base::RowXpr operator[](const unsigned int i) const
        { return Base::row(i); }


        // FIXME what the hell is that !
        /*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];
                }
        };*/

        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));
        };
};

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

#endif