ublascvmatrix.hxx

Go to the documentation of this file.

/************************************************************************/
/*                                                                      */
/*               Copyright 2004-2005 by Hirotaka Niitsuma               */
/*                                                                      */
/*                                                                      */
/*    This file is part of the STLLCV computer vision library.          */
/*    ( Version 0.1, Sep 28 2005 )                                      */
/*    You may use, modify, and distribute this software according       */
/*    to the terms stated in the LICENSE file included in               */
/*    the STLLCV distribution.                                          */
/*                                                                      */
/*    The STLLCV Website is                                             */
/*        http://www2s.biglobe.ne.jp/~niitsuma/STLLCV/                  */
/*    Please direct questions, bug reports, and contributions to        */
/*        niitsuma@mub.biglobe.ne.jp�@�@�@                              */
/*                                                                      */
/*  THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR          */
/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED      */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
/*                                                                      */
/************************************************************************/

#ifndef UBLASCVMATRIX_HXX
#define UBLASCVMATRIX_HXX


#include <boost/numeric/ublas/matrix.hpp>   
#include <boost/numeric/ublas/vector.hpp>  
#include <boost/numeric/ublas/lu.hpp> 
#include <boost/numeric/ublas/io.hpp>

#include "cv.h"

template<class PIXELTYPE>class CCvMatDepth      {public: int depth;CCvMatDepth(){depth= sizeof(PIXELTYPE);}};
template<>class CCvMatDepth<unsigned char>      {public: int depth;CCvMatDepth(){depth= CV_8U ;}};
template<>class CCvMatDepth<char>                       {public: int depth;CCvMatDepth(){depth= CV_8S;}};
template<>class CCvMatDepth<unsigned short>     {public: int depth;CCvMatDepth(){depth= CV_16U;}};
template<>class CCvMatDepth<short>                              {public: int depth;CCvMatDepth(){depth= CV_16S;}};
template<>class CCvMatDepth<int>                        {public: int depth;CCvMatDepth(){depth= CV_32S;}};
template<>class CCvMatDepth<float>                      {public: int depth;CCvMatDepth(){depth= CV_32F;}};
template<>class CCvMatDepth<double>                     {public: int depth;CCvMatDepth(){depth= CV_64F;}};

/********************************************************/
/*                                                      */
/*                    CublasCvMatrix                   */
/*                                                      */
/********************************************************/

template < class T,unsigned int Ni,unsigned int Nj >
class  CublasCvMatrix: public boost::numeric::ublas::c_matrix<T,Ni,Nj>  
                                        , public CvMat // CvMat::data and c_matrix::data()  conflicted
{
public:
        typedef boost::numeric::ublas::c_matrix<T,Ni,Nj> ublas_c_matrix_type;
        CCvMatDepth<T> cvMatDepth;
        ublas_c_matrix_type *const p_ublas_matrix ; //,publas;
        CvMat *const  pCvMat; //,pCv ;  

        void initializeData()
        {
                pCvMat->data.ptr =reinterpret_cast<uchar*>(&(*p_ublas_matrix)(0,0));
                cvInitMatHeader( pCvMat,Nj, Ni
               ,cvMatDepth.depth
                           , reinterpret_cast<uchar*>(&(*p_ublas_matrix)(0,0))
                           , sizeof(T)*Nj);
        }
        CublasCvMatrix():p_ublas_matrix(this),pCvMat(this)
        {
                initializeData();
        }
        CublasCvMatrix(const CublasCvMatrix<T,Ni,Nj> &inputMatrix ):p_ublas_matrix(this),pCvMat(this)
        {
                initializeData();
                *p_ublas_matrix = ( ublas_c_matrix_type)inputMatrix;
        }       
        CublasCvMatrix(const ublas_c_matrix_type     &inputMatrix ):p_ublas_matrix(this),pCvMat(this)
        {
                initializeData();
                *p_ublas_matrix = ( ublas_c_matrix_type)inputMatrix;
        }
        CublasCvMatrix<T,Ni,Nj>& operator=(ublas_c_matrix_type inputMatrix)
        {
                *p_ublas_matrix = inputMatrix;
        return *this;
    }
        CublasCvMatrix<T,Ni,Nj>& operator=(CvMat inputMatrix)
        {
                T * pValue = reinterpret_cast<T*>(inputMatrix.data.ptr);
                std::copy(pValue ,pValue +Nj*Nj,p_ublas_matrix->data());
        return *this;
    }

        CublasCvMatrix<T,Ni,Nj>& operator=(CublasCvMatrix<T,Ni,Nj> inputMatrix)
        {
                *p_ublas_matrix = inputMatrix;
        return *this;
    }

};


/********************************************************/
/*                                                      */
/*                   CublasCvVector                     */
/*                                                      */
/********************************************************/

template < class T,unsigned int N>
class  CublasCvVector: public boost::numeric::ublas::c_vector<T,N>  
                                        , public CvMat // CvMat::data and c_matrix::data()  conflicted
{
public:
        typedef boost::numeric::ublas::c_vector<T,N> ublas_c_vector_type;
        CCvMatDepth<T> cvMatDepth;
        CvMat *const pCvMat;//,*pCv; 
        ublas_c_vector_type *const p_ublas_vector;//,*publas;
        
        void initializeData()
        {
                pCvMat->data.ptr =reinterpret_cast<uchar*>( p_ublas_vector->data() );
                cvInitMatHeader( pCvMat
                        ,N , 1 //collum vector
               ,cvMatDepth.depth
                           , reinterpret_cast<uchar*>(p_ublas_vector->data())
                           , sizeof(T));
        }
        CublasCvVector():p_ublas_vector(this),pCvMat(this)
        {
                initializeData();
                *p_ublas_vector = boost::numeric::ublas::zero_vector<T>(N);
        }
        CublasCvVector( const CublasCvVector<T,N> &inputVector):p_ublas_vector(this),pCvMat(this)
        {
                initializeData();
                *p_ublas_vector = (ublas_c_vector_type)inputVector;
        }       
        CublasCvVector( const ublas_c_vector_type &inputVector):p_ublas_vector(this),pCvMat(this)
        {
                initializeData();
                *p_ublas_vector = (ublas_c_vector_type)inputVector;
        }

        CublasCvVector<T,N>& operator=(ublas_c_vector_type inputVector)
        {
                *p_ublas_vector = inputVector;
        return *this;
    }
        CublasCvVector<T,N>& operator=(CvMat inputMatrix)
        {
                T * pValue = reinterpret_cast<T*>(inputMatrix.data.ptr);
                std::copy(pValue ,pValue +Nj*Nj,p_ublas_vector->data());
        return *this;
    }
        CublasCvVector<T,N>& operator=(CublasCvVector<T,N> inputVector)
        {
                *p_ublas_vector = inputVector ;
                        //reinterpret_cast<ublas_c_vector_type >(inputVector);
        return *this;
    }
};

template < class T,unsigned int N>
inverseUblasCvMatrix(CublasCvMatrix<T,N,N> &matInput, CublasCvMatrix<T,N,N> &matOut){
        cvmInvert( &(CvMat)matInput, &(CvMat)matOut );
}

template < class T,unsigned int N>
struct inverseUblasCvMatrixFunctor{
         CublasCvMatrix<T,N,N> operator ()(CublasCvMatrix<T,N,N> &matInput)
         {
                CublasCvMatrix<T,N,N> matOut;            
                inverseUblasCvMatrix<T,N>(matInput, matOut){
                return matOut;
         }
}
};



//The following  codes are only test code

/********************************************************/
/*                                                      */
/*                    CWrapCvMat                        */
/*                                                      */
/********************************************************/

template < class WrapMatrixClass = boost::numeric::ublas::matrix<float> >
class  CWrapCvMat: public WrapMatrixClass
                                        , public CvMat // CvMat::data and c_matrix::data()  conflicted
{
public:
        typedef WrapMatrixClass wrap_matrix_type;
        typedef typename WrapMatrixClass::value_type value_type;

        CCvMatDepth< typename WrapMatrixClass::value_type > cvMatDepth;
        wrap_matrix_type *const p_wrap_matrix ; //,publas;
        CvMat *const  pCvMat; //,pCv ;  

        void initializeData()
        {
                pCvMat->data.ptr =reinterpret_cast<uchar*>(&(*p_wrap_matrix)[0,0]);
                cvInitMatHeader( pCvMat,p_wrap_matrix->size1(), p_wrap_matrix->size2()
               ,cvMatDepth.depth
                           , reinterpret_cast<uchar*>(&(*p_wrap_matrix)[0,0])
                           , sizeof(value_type)*p_wrap_matrix->size2());
        }
#if 0
        CWrapCvMat():p_wrap_matrix(this),pCvMat(this)
        {
                initializeData();
        }
#endif
        CWrapCvMat(int n1, int n2):WrapMatrixClass(n1,n2), p_wrap_matrix(this),pCvMat(this)
        {
                initializeData();
        }
        CWrapCvMat(const CWrapCvMat<WrapMatrixClass> &inputMatrix ):WrapMatrixClass(inputMatrix),p_wrap_matrix(this),pCvMat(this)
        {
                initializeData();
        }       
        CWrapCvMat(const WrapMatrixClass &inputMatrix ):WrapMatrixClass(inputMatrix),p_wrap_matrix(this),pCvMat(this)
        {
                initializeData();
        }       
        CWrapCvMat<WrapMatrixClass>& operator=(wrap_matrix_type inputMatrix)
        {
                *p_wrap_matrix = inputMatrix;
        return *this;
    }
        CWrapCvMat<WrapMatrixClass>& operator=(CvMat inputMatrix)
        {
                T * pValue = reinterpret_cast<value_type*>(inputMatrix.data.ptr);
                std::copy(pValue ,pValue +p_wrap_matrix->size1()*p_wrap_matrix->size2()
                        ,p_wrap_matrix->data());
        return *this;
    }
        CWrapCvMat<WrapMatrixClass>& operator=(CWrapCvMat<WrapMatrixClass>  inputMatrix)
        {
                //*p_wrap_matrix = reinterpret_cast<wrap_matrix_type>(inputMatrix);
                *p_wrap_matrix = inputMatrix;
        return *this;
    }
};



/*
template < class WrapMatrixClass = boost::numeric::ublas::matrix<float > >
class  CCvMatWrapped: public WrapMatrixClass
                                        , public CvMat // CvMat::data and c_matrix::data()  conflicted
{
public:
        typedef WrapMatrixClass wrap_matrix_type;
        typedef typename WrapMatrixClass::value_type value_type;

        CCvMatDepth< typename WrapMatrixClass::value_type > cvMatDepth;
        wrap_matrix_type *const p_wrap_matrix_type ; //,publas;
        CvMat *const  pCvMat; //,pCv ;  

        char * initializeData(int n1,int n2)
        {
                //pCvMat->data.ptr =reinterpret_cast<uchar*>(&(*p_wrap_matrix_type)(0,0));
                cvInitMatHeader( 
                                //pCvMat
                                (CvMat)this
                                ,Nj, Ni
               ,cvMatDepth.depth
                           //, reinterpret_cast<uchar*>(&(*p_wrap_matrix_type)(0,0))
                           ((CvMat)this)->data.ptr
                           , sizeof(T)*Nj);
                cvCreateData( 
                        //pCvMat 
                        ((CvMat)this)
                        );
                //return pCvMat->data.ptr
                return ((CvMat)this)->data.ptr
        }
        CCvMatWrapped(int n1,int n2):
                CvMat()
                ,WrapMatrixClass(n1,n2
                //,reinterpret_cast< 
                        //typename WrapMatrixClass::value_type *
                //      typename WrapMatrixClass::array_type
                >(initializeData(n1,n2)) )
                ,pCvMat(this)
                ,p_wrap_matrix_type(this)
        {}
};
*/



#endif /*  UBLASCVMATRIX_HXX */

---