Matrix.h

/* 
*  Copyright 2012 Matthias Fuchs
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*/

#ifndef STROMX_CVSUPPORT_MATRIX_H
#define STROMX_CVSUPPORT_MATRIX_H

#include <string>
#include <vector>
#include "stromx/cvsupport/Config.h"
#include <stromx/runtime/MatrixWrapper.h>

namespace cv
{
    class Mat;
    class MatExpr;
    
    template <class T>
    class Rect_;
    typedef Rect_<int> Rect;
    
    class RotatedRect;
}

namespace stromx
{
    namespace cvsupport
    {
        class STROMX_CVSUPPORT_API Matrix : public runtime::MatrixWrapper
        {
            friend STROMX_CVSUPPORT_API cv::Mat getOpenCvMat(const runtime::Matrix& matrix,
                                                             const unsigned int numChannels);
        
        public:
            
            Matrix();
            
            Matrix(const stromx::cvsupport::Matrix& matrix);
            
            explicit Matrix(const unsigned int rows, const unsigned int cols, const ValueType valueType);
            
            explicit Matrix(cv::Mat& cvMatrix);
            
            explicit Matrix(const cv::MatExpr& cvMatExpr);
            
            explicit Matrix(const stromx::runtime::Matrix& matrix);
            
            explicit Matrix(const cv::Rect& cvRect);
            
            explicit Matrix(const cv::RotatedRect& cvRotatedRect);
            
            explicit Matrix(const unsigned int size);
            
            explicit Matrix(const std::string & filename);
            
            virtual ~Matrix();
            
            virtual const runtime::Version & version() const { return VERSION; }
            virtual const std::string & type() const { return TYPE; }
            virtual const std::string & package() const { return PACKAGE; }
            
            virtual Data* clone() const;
            
            const Matrix & operator=(const runtime::Matrix & matrix);
            
            
            static cvsupport::Matrix eye(const unsigned int rows, 
                                         const unsigned int cols,
                                         const ValueType valueType);
            
            
            static cvsupport::Matrix zeros(const unsigned int rows, 
                                           const unsigned int cols,
                                           const ValueType valueType);
            
        private:
            static const std::string TYPE;
            static const std::string PACKAGE;
            static const runtime::Version VERSION;
            
            static int cvTypeFromValueType(const runtime::Matrix::ValueType valueType,
                                           const unsigned int numChannels = 1);
            static runtime::Matrix::ValueType valueTypeFromCvType(const int cvType);
            
            void copy(const stromx::runtime::Matrix & matrix);
            void allocate(const unsigned int rows, const unsigned int cols, const runtime::Matrix::ValueType valueType);
            void getDataFromCvMatrix(const ValueType valueType);
            
            cv::Mat* m_matrix;
        };
    }
}

#endif // STROMX_CVSUPPORT_MATRIX_H