dataobj.h

/* ********************************************************************
 itom software
 URL: http://www.uni-stuttgart.de/ito
 Copyright (C) 2020, Institut fuer Technische Optik (ITO),
 Universitaet Stuttgart, Germany
 
 This file is part of itom and its software development toolkit (SDK).
 
 itom is free software; you can redistribute it and/or modify it
 under the terms of the GNU Library General Public Licence as published by
 the Free Software Foundation; either version 2 of the Licence, or (at
 your option) any later version.
 
 In addition, as a special exception, the Institut fuer Technische
 Optik (ITO) gives you certain additional rights.
 These rights are described in the ITO LGPL Exception version 1.0,
 which can be found in the file LGPL_EXCEPTION.txt in this package.
 
 itom 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 Library
 General Public Licence for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with itom. If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************** */

#ifndef __DATAOBJH
#define __DATAOBJH

#include "defines.h"

#include <cstdlib>
#include <iostream>
#include <complex>
#include <limits>
#include <string>

#ifdef WIN32
    #pragma warning(disable:4996)
#endif

#define NOMINMAX //see: http://social.msdn.microsoft.com/Forums/sv/vclanguage/thread/d986a370-d856-4f9e-9f14-53f3b18ab63e, this is only an issue with OpenCV 2.4.3, not 2.3.x

#include "opencv2/opencv.hpp"
#include "opencv2/core/core.hpp"
#include "opencv2/core/types_c.h"

#include "../common/sharedStructures.h"
#include "../common/color.h"
#include "../common/byteArray.h"


namespace cv
{
    template<> inline ito::float32 saturate_cast<ito::float32>( ito::float64 v)
    {
        if(cvIsInf(v)) return std::numeric_limits<ito::float32>::infinity();
        if(cvIsNaN(v)) return std::numeric_limits<ito::float32>::quiet_NaN();
        return static_cast<ito::float32>(std::max ( (ito::float64)(- (std::numeric_limits<ito::float32>::max)()) ,  std::min ( v , (ito::float64) ((std::numeric_limits<ito::float32>::max)()) )));
    }
    
    template<> inline ito::float64 saturate_cast<ito::float64>( ito::float32 v)
    {
        if(cvIsInf(v)) return std::numeric_limits<ito::float64>::infinity();
        if(cvIsNaN(v)) return std::numeric_limits<ito::float64>::quiet_NaN();
        return static_cast<ito::float64>(v);
    }
    
    template<typename _Tp> static inline _Tp saturate_cast(ito::complex128 /*v*/) {     cv::error(cv::Exception(CV_StsAssert, "Not defined for input parameter type", "", __FILE__, __LINE__)); return 0; }
    template<typename _Tp> static inline _Tp saturate_cast(ito::complex64 /*v*/) {     cv::error(cv::Exception(CV_StsAssert, "Not defined for input parameter type", "", __FILE__, __LINE__)); return 0; }
    
    template<typename _Tp> static inline _Tp saturate_cast(ito::Rgba32 /*v*/) {     cv::error(cv::Exception(CV_StsAssert, "Not defined for input parameter type", "", __FILE__, __LINE__)); return 0; }
    //   template<typename _Tp> static inline ito::Rgba32 saturate_cast(_Tp /*v*/) {     cv::error(cv::Exception(CV_StsAssert, "Not defined for input parameter type", "", __FILE__, __LINE__)); return 0; }
    
    template<> inline ito::complex64 saturate_cast(ito::uint8 v){ return ito::complex64(static_cast<ito::float32>(v),0.0); }
    template<> inline ito::complex64 saturate_cast(ito::int8 v){ return ito::complex64(static_cast<ito::float32>(v),0.0); }
    template<> inline ito::complex64 saturate_cast(ito::uint16 v){ return ito::complex64(static_cast<ito::float32>(v),0.0); }
    template<> inline ito::complex64 saturate_cast(ito::int16 v){ return ito::complex64(static_cast<ito::float32>(v),0.0); }
    template<> inline ito::complex64 saturate_cast(ito::uint32 v){ return ito::complex64(static_cast<ito::float32>(v),0.0); }
    template<> inline ito::complex64 saturate_cast(ito::int32 v){ return ito::complex64(static_cast<ito::float32>(v),0.0); }
    template<> inline ito::complex64 saturate_cast(ito::float32 v){ return ito::complex64(v,0.0); }
    template<> inline ito::complex64 saturate_cast(ito::float64 v){ return ito::complex64(saturate_cast<ito::float32>(v),0.0); }
    template<> inline ito::complex64 saturate_cast(ito::complex64 v){ return v; }
    template<> inline ito::complex64 saturate_cast(ito::complex128 v){ return std::complex<ito::float32>(saturate_cast<ito::float32>(v.real()),saturate_cast<ito::float32>(v.imag())); }
    
    template<> inline ito::complex128 saturate_cast(ito::uint8 v){ return ito::complex128(static_cast<ito::float64>(v),0.0); }
    template<> inline ito::complex128 saturate_cast(ito::int8 v){ return ito::complex128(static_cast<ito::float64>(v),0.0); }
    template<> inline ito::complex128 saturate_cast(ito::uint16 v){ return ito::complex128(static_cast<ito::float64>(v),0.0); }
    template<> inline ito::complex128 saturate_cast(ito::int16 v){ return ito::complex128(static_cast<ito::float64>(v),0.0); }
    template<> inline ito::complex128 saturate_cast(ito::uint32 v){ return ito::complex128(static_cast<ito::float64>(v),0.0); }
    template<> inline ito::complex128 saturate_cast(ito::int32 v){ return ito::complex128(static_cast<ito::float64>(v),0.0); }
    template<> inline ito::complex128 saturate_cast(ito::float32 v){ return ito::complex128(saturate_cast<ito::float64>(v),0.0); }
    template<> inline ito::complex128 saturate_cast(ito::float64 v){ return ito::complex128(v,0.0); }
    template<> inline ito::complex128 saturate_cast(ito::complex64 v){ return ito::complex128(saturate_cast<ito::float64>(v.real()),saturate_cast<ito::float64>(v.imag())); }
    template<> inline ito::complex128 saturate_cast(ito::complex128 v){ return v; }
    
    // template<> inline ito::Rgba32 saturate_cast(ito::int8 v) {return ito::Rgba32(saturate_cast<ito::uint8>(v));}
    template<> inline ito::Rgba32 saturate_cast(ito::uint8 v) {return ito::Rgba32(v);}
    template<> inline ito::Rgba32 saturate_cast(ito::uint16 v){return ito::Rgba32(saturate_cast<ito::uint8>(v));}
    // template<> inline ito::Rgba32 saturate_cast(ito::int16 v){return ito::Rgba32(saturate_cast<ito::uint8>(v));}
    template<> inline ito::Rgba32 saturate_cast(ito::uint32 v)
    {
        return ito::Rgba32::fromUnsignedLong(v);
    }
    template<> inline ito::Rgba32 saturate_cast(ito::int32 v)
    {
        ito::Rgba32 temp;
        temp.rgba = static_cast<ito::uint32>(v);
        return temp;
    }
    template<> inline ito::Rgba32 saturate_cast(ito::float32 v){return ito::Rgba32(saturate_cast<ito::uint8>(v));}
    template<> inline ito::Rgba32 saturate_cast(ito::float64 v){return ito::Rgba32(saturate_cast<ito::uint8>(v));}
    template<> inline ito::Rgba32 saturate_cast(ito::Rgba32 v){return v;}
    
    template<> inline ito::Rgba32 saturate_cast(ito::int8 /*v*/) { cv::error(cv::Exception(CV_StsAssert, "Cast from int8 to rgba32 not defined.", "", __FILE__, __LINE__)); return ito::Rgba32(); }
    template<> inline ito::Rgba32 saturate_cast(ito::int16 /*v*/) { cv::error(cv::Exception(CV_StsAssert, "Cast from int16 to rgba32 not defined.", "", __FILE__, __LINE__)); return ito::Rgba32(); }
    template<> inline ito::Rgba32 saturate_cast(ito::complex128 /*v*/) { cv::error(cv::Exception(CV_StsAssert, "Cast from complex128 to rgba32 not defined.", "", __FILE__, __LINE__)); return ito::Rgba32(); }
    template<> inline ito::Rgba32 saturate_cast(ito::complex64 /*v*/) {  cv::error(cv::Exception(CV_StsAssert, "Cast from complex64 to rgba32 not defined.", "", __FILE__, __LINE__)); return ito::Rgba32(); }
    
    template<> inline ito::uint8 saturate_cast(ito::Rgba32 v){return saturate_cast<ito::uint8>(v.gray());};
    //template<> inline ito::int16 saturate_cast(ito::Rgba32 v){return saturate_cast<ito::int16>(v.gray());};
    template<> inline ito::uint16 saturate_cast(ito::Rgba32 v){return saturate_cast<ito::uint16>(v.gray());};
    template<> inline ito::uint32 saturate_cast(ito::Rgba32 v){return v.argb();};
    template<> inline ito::int32 saturate_cast(ito::Rgba32 v){return (ito::int32)(v.argb());};
    template<> inline ito::float32 saturate_cast(ito::Rgba32 v){return v.gray();};
    template<> inline ito::float64 saturate_cast(ito::Rgba32 v){return (ito::float64)v.gray();};

#if (CV_MAJOR_VERSION > 3) || (CV_MAJOR_VERSION == 3 && CV_MINOR_VERSION >= 3)
    //from CV 3.3.1 on, the default implementation of DataType is dropped:
    //Original note in traits.hpp of OpenCV: Default values were dropped to stop confusing developers about using of unsupported types (see #7599)
    template<> class DataType<ito::uint32>
    {
    public:
        typedef ito::uint32 value_type;
        typedef value_type work_type;
        typedef value_type channel_type;
        typedef value_type vec_type;
        enum { generic_type = 1, depth = -1, channels = 1, fmt=0,
            type = CV_MAKETYPE(depth, channels) };
    };
#endif
    
    template<> class DataType<ito::Rgba32>
    {
    public:
        typedef ito::Rgba32 value_type;
        typedef ito::uint8 channel_type;
        typedef Vec<channel_type, 4> work_type;
        typedef value_type vec_type;
        enum
        {
            generic_type = 0,
            depth = cv::DataDepth<channel_type>::value,
            channels = 4,
            fmt = ((channels-1)<<8) + cv::DataDepth<channel_type>::fmt,
            type = CV_MAKETYPE(depth, channels)
        };
    };
    
    template<> class DataType<ito::RedChannel>
    {
    public:
        typedef ito::RedChannel value_type;
        typedef ito::uint8 channel_type;
        typedef Vec<channel_type, 4> work_type;
        typedef value_type vec_type;
        enum
        {
            generic_type = 0,
            depth = cv::DataDepth<channel_type>::value,
            channels = 4,
            fmt = ((channels-1)<<8) + cv::DataDepth<channel_type>::fmt,
            type = CV_MAKETYPE(depth, channels)
        };
    };
    
    template<> class DataType<ito::GreenChannel>
    {
    public:
        typedef ito::GreenChannel value_type;
        typedef ito::uint8 channel_type;
        typedef Vec<channel_type, 4> work_type;
        typedef value_type vec_type;
        enum
        {
            generic_type = 0,
            depth = cv::DataDepth<channel_type>::value,
            channels = 4,
            fmt = ((channels-1)<<8) + cv::DataDepth<channel_type>::fmt,
            type = CV_MAKETYPE(depth, channels)
        };
    };
    
    template<> class DataType<ito::BlueChannel>
    {
    public:
        typedef ito::BlueChannel value_type;
        typedef ito::uint8 channel_type;
        typedef Vec<channel_type, 4> work_type;
        typedef value_type vec_type;
        enum
        {
            generic_type = 0,
            depth = cv::DataDepth<channel_type>::value,
            channels = 4,
            fmt = ((channels-1)<<8) + cv::DataDepth<channel_type>::fmt,
            type = CV_MAKETYPE(depth, channels)
        };
    };
    
    template<> class DataType<ito::AlphaChannel>
    {
    public:
        typedef ito::AlphaChannel value_type;
        typedef ito::uint8 channel_type;
        typedef Vec<channel_type, 4> work_type;
        typedef value_type vec_type;
        enum
        {
            generic_type = 0,
            depth = cv::DataDepth<channel_type>::value,
            channels = 4,
            fmt = ((channels-1)<<8) + cv::DataDepth<channel_type>::fmt,
            type = CV_MAKETYPE(depth, channels)
        };
    };
    
    
} // namespace cv

namespace ito {
    
#define __ITODEBUG 1
    
    //forward declarations
    class DObjIterator;
    class DataObject;
    class Range;
    class DataObjectTags;
    class DataObjectTagType;
    class DataObjectTagsPrivate;
    
    
    //----------------------------------------------------------------------------------------------------------------------------------
    class DATAOBJ_EXPORT Range
    {
    public:
        Range() : start(0), end(0) {}                           
        Range(int _start, int _end) { _start < _end ? (end = _end, start = _start) : (start = _end, end = _start); }  
        inline unsigned int size() const { return end - start; }
        inline bool empty() const { return (start == end); }    
        static Range all() { return Range(INT_MIN, INT_MAX); }  
        int start;                                               
        int end;                                                 
    };
    
    //----------------------------------------------------------------------------------------------------------------------------------
    class DATAOBJ_EXPORT DataObjectTagType
    {
    public:
        enum tTagType
        {
            typeInvalid     = 0x000000, 
            typeDouble      = 0x000008, 
            typeString      = 0x000020  
        };
        
    private:
        double m_dVal;          
        tTagType m_type;        
        ByteArray m_strValue;   
        
    public:
        DataObjectTagType() : m_dVal(0), m_strValue(""), m_type(DataObjectTagType::typeInvalid){}
        DataObjectTagType(double dVal) : m_dVal(dVal), m_strValue(""), m_type(DataObjectTagType::typeDouble){}
        DataObjectTagType(const std::string &str) : m_dVal(std::numeric_limits<double>::quiet_NaN()), m_type(DataObjectTagType::typeString){ m_strValue = str.data(); }
        DataObjectTagType(const ByteArray &str) : m_dVal(std::numeric_limits<double>::quiet_NaN()), m_type(DataObjectTagType::typeString){ m_strValue = str; }
        DataObjectTagType(const char* cVal) : m_dVal(std::numeric_limits<double>::quiet_NaN()), m_type(DataObjectTagType::typeString){ cVal == NULL ?  m_strValue = "" : m_strValue = cVal;}
        DataObjectTagType(const DataObjectTagType& a) : m_dVal(a.m_dVal), m_type(a.m_type), m_strValue(a.m_strValue) {}
        
        DataObjectTagType & operator = (const DataObjectTagType &rhs)
        {
            this->m_dVal = rhs.m_dVal;
            this->m_strValue = rhs.m_strValue;
            this->m_type = rhs.m_type;
            
            return *this;
        }
        
        inline int getType(void) const {return m_type;}
        
        inline bool isValid(void) const { return (m_type == DataObjectTagType::typeInvalid) ? false: true;}
        
        inline double getVal_ToDouble(void)
        {
            if(m_type == DataObjectTagType::typeInvalid)
            {
                return std::numeric_limits<double>::quiet_NaN();
            }
            else if(m_type == DataObjectTagType::typeDouble)
            {
                return m_dVal;
            }
            else
            {
                double dVal = std::numeric_limits<double>::quiet_NaN();
                //dVal = atof(m_strValue.c_str()); //sometimes the result of that line has been arbitrary, therefore this conversion should fail.
                return dVal;
            }
        }
        
        inline ByteArray getVal_ToString(void)
        {
            if(m_type == DataObjectTagType::typeInvalid)
            {
                return "";
            }
            else if(m_type == DataObjectTagType::typeString)
            {
                return m_strValue;
            }
            else
            {
                if (cvIsNaN(m_dVal)) return "NaN";
                if (cvIsInf(m_dVal)) return "Inf";
                
                std::ostringstream strs;
                strs << m_dVal;
                ByteArray ba(strs.str().data());
                
                return ba;
            }
        }
    };
    
    //----------------------------------------------------------------------------------------------------------------------------------
    class DATAOBJ_EXPORT DObjConstIterator
    {
    public:
        
        DObjConstIterator();
        
        DObjConstIterator(const DataObject* _dObj, int pos = 0);
        
        DObjConstIterator(const DObjConstIterator& it);
        
        DObjConstIterator& operator = (const DObjConstIterator& it);
        
        const uchar* operator *() const;
        
        const uchar* operator [](int i) const;
        
        DObjConstIterator& operator += (int ofs);
        
        DObjConstIterator& operator -= (int ofs);
        
        DObjConstIterator& operator --();
        
        DObjConstIterator operator --(int);
        
        DObjConstIterator& operator ++();
        
        DObjConstIterator operator ++(int);
        
        bool operator == (const DObjConstIterator& dObjIt);
        bool operator != (const DObjConstIterator& dObjIt);
        bool operator < (const DObjConstIterator& dObjIt);
        bool operator > (const DObjConstIterator& dObjIt);
        bool operator <= (const DObjConstIterator& dObjIt);
        bool operator >= (const DObjConstIterator& dObjIt);
        
    protected:
        void seekAbs(int ofs);
        
        void seekRel(int ofs);
        
        const DataObject* dObj; 
        bool   planeContinuous; 
        int elemSize;           
        uchar* ptr;             
        uchar* sliceStart;      
        uchar* sliceEnd;        
        int plane;              
    };
    
    //----------------------------------------------------------------------------------------------------------------------------------
    class DATAOBJ_EXPORT DObjIterator : public DObjConstIterator
    {
    public:
        
        DObjIterator();
        
        DObjIterator(DataObject* _dObj, int pos = 0);
        
        DObjIterator(const DObjIterator& it);
        
        DObjIterator& operator = (const DObjIterator& it);
        
        uchar* operator *();
        
        uchar* operator [](int i);
        
        DObjIterator& operator += (int ofs);
        
        DObjIterator& operator -= (int ofs);
        
        DObjIterator& operator --();
        
        DObjIterator operator --(int);
        
        DObjIterator& operator ++();
        
        DObjIterator operator ++(int);
    };

//----------------------------------------------------------------------------------------------------------------------------------

// Forward declaration of friend methods
#ifdef __APPLE__
    template<typename _Tp> RetVal CreateFunc(DataObject *dObj, const unsigned char dimensions, const int *sizes, const unsigned char continuous, const uchar* continuousDataPtr, const int* steps);
    template<typename _Tp> RetVal CreateFuncWithCVPlanes(DataObject *dObj, const unsigned char dimensions, const int *sizes, const cv::Mat* planes, const unsigned int nrOfPlanes);
    template<typename _Tp> RetVal FreeFunc(DataObject *dObj);
    template<typename _Tp> RetVal SecureFreeFunc(DataObject *dObj);
    template<typename _Tp> RetVal CopyToFunc(const DataObject &lhs, DataObject &rhs, unsigned char regionOnly);
    template<typename _Tp> RetVal ConvertToFunc(const DataObject &lhs, DataObject &rhs, const int type, const double alpha, const double beta);
    template<typename _Tp> RetVal AdjustROIFunc(DataObject *dObj, const int *lims);
    //template<typename _Tp> RetVal MinMaxLocFunc(const DataObject &dObj, double *minVal, double *maxVal, int *minPos, int *maxPos);
    template<typename _Tp> RetVal AssignScalarFunc(const DataObject *src, const ito::tDataType type, const void *scalar);
    template<typename _Tp> RetVal MakeContinuousFunc(const DataObject &dObj, DataObject &resDObj);
    template<typename _Tp> RetVal EvaluateTransposeFlagFunc(DataObject *dObj);
    template<typename _Tp> std::ostream& coutFunc(std::ostream& out, const DataObject& dObj);
    
    // more friends due to change of std::vector to int ** for m_data ...
    template<typename _Tp> RetVal GetRangeFunc(DataObject *dObj, const int dtop, const int dbottom, const int dleft, const int dright);
    template<typename _Tp> RetVal AdjustROIFunc(DataObject *dObj, int dtop, int dbottom, int dleft, int dright);
#endif // __APPLE__
    
    class DATAOBJ_EXPORT DataObject
    {
    private:
        void createHeader(const unsigned char dimensions, const int *sizes, const int *steps, const int elemSize);
        
        void createHeaderWithROI(const unsigned char dimensions, const int *sizes, const int *osizes = NULL, const int *roi = NULL);
        
        void create(const unsigned char dimensions, const int *sizes, const int type, const unsigned char continuous, const uchar* continuousDataPtr = NULL, const int* steps = NULL);  
        void create(const unsigned char dimensions, const int *sizes, const int type, const cv::Mat* planes, const unsigned int nrOfPlanes);
        
        void freeData(void);     
        void secureFreeData(void); 
        //----------------------------------------------------------------------------------------------------------------------------------
        ito::RetVal matNumToIdx(const int matNum, int *matIdx) const;
        
        ito::RetVal matIdxToNum(const unsigned int *matIdx, int *matNum) const;
        
        
        struct DATAOBJ_EXPORT MSize
        {
            inline MSize() : m_p(NULL) {}
            inline int operator [] (const int dim) const
            {
                return m_p[dim]; //return the size value. this operator corresponds to the real data representation in memory
            };
            inline operator const int * () const { return m_p; }
            inline bool operator == (const MSize& sz) const
            {
                if(m_p == NULL || sz.m_p == NULL)
                {
                    return sz.m_p == m_p;
                }
                
                int d = m_p[-1]; 
                if( d != sz.m_p[-1] )
                    return false;

                return (memcmp(m_p, sz.m_p, d * sizeof(int)) == 0); //returns true if the size vector (having the same length) is equal
            }
            
            inline bool operator != (const MSize& sz) const { return !(*this == sz); }
            
            int *m_p;
        };
        
        
        struct DATAOBJ_EXPORT MROI
        {
            inline MROI() : m_p(NULL) {};
            inline int operator [] (const int dim) const
            {
                return m_p[dim]; //return the size value. this operator corresponds to the real data representation in memory
            }
            
            inline bool operator == (const MROI & rroi) const
            {
                if(m_p == NULL || rroi.m_p == NULL)
                {
                    return rroi.m_p == m_p;
                }

                int d = m_p[-1]; 
                if( d != rroi.m_p[-1] )
                    return false;

                return (memcmp(m_p, rroi.m_p, d * sizeof(int)) == 0); //returns true if the size vector (having the same length) is equal
                
                if (m_p[-1] != rroi.m_p[-1])
                {
                    return false;
                }
            }
            
            int *m_p;
        };
        
        DataObject(const DataObject& dObj, bool transposed);    
        char    m_continuous;                        
        char    m_owndata;                           
        int     m_type;                              
        int     *m_pRefCount;                        
        int     m_dims;                              
        MSize   m_osize;                             
        MROI    m_roi;                               
        MSize   m_size;                              
        uchar  **m_data;                             
        DataObjectTagsPrivate *m_pDataObjectTags;    
        static const int m_sizeofs;
        
        int mdata_realloc(const int size);
        int mdata_size(void) const;
        int mdata_free();
        
        RetVal copyFromData2DInternal(const uchar* src, const int sizeOfElem, const int sizeX, const int sizeY);
        RetVal copyFromData2DInternal(const uchar* src, const int sizeOfElem, const int sizeX, const int x0, const int y0, const int width, const int height);

        //low-level, templated methods
        //most low-level methods are marked "friend" such that they can access private members of their data object parameters
        template<typename _Tp> friend RetVal CreateFunc(DataObject *dObj, const unsigned char dimensions, const int *sizes, const unsigned char continuous, const uchar* continuousDataPtr, const int* steps);
        template<typename _Tp> friend RetVal CreateFuncWithCVPlanes(DataObject *dObj, const unsigned char dimensions, const int *sizes, const cv::Mat* planes, const unsigned int nrOfPlanes);
        template<typename _Tp> friend RetVal FreeFunc(DataObject *dObj);
        template<typename _Tp> friend RetVal SecureFreeFunc(DataObject *dObj);
        template<typename _Tp> friend RetVal CopyToFunc(const DataObject &lhs, DataObject &rhs, unsigned char regionOnly);
        template<typename _Tp> friend RetVal ConvertToFunc(const DataObject &lhs, DataObject &rhs, const int type, const double alpha, const double beta);
        template<typename _Tp> friend RetVal AdjustROIFunc(DataObject *dObj, const int *lims);
        //template<typename _Tp> friend RetVal MinMaxLocFunc(const DataObject &dObj, double *minVal, double *maxVal, int *minPos, int *maxPos);
        template<typename _Tp> friend RetVal AssignScalarFunc(const DataObject *src, const ito::tDataType type, const void *scalar);
        template<typename _Tp> friend RetVal MakeContinuousFunc(const DataObject &dObj, DataObject &resDObj);
        template<typename _Tp> friend RetVal EvaluateTransposeFlagFunc(DataObject *dObj);
        template<typename _Tp> friend std::ostream& coutFunc(std::ostream& out, const DataObject& dObj);
        
        // more friends due to change of std::vector to int ** for m_data ...
        template<typename _Tp> friend RetVal GetRangeFunc(DataObject *dObj, const int dtop, const int dbottom, const int dleft, const int dright);
        template<typename _Tp> friend RetVal AdjustROIFunc(DataObject *dObj, int dtop, int dbottom, int dleft, int dright);
        
    public:
        DataObject(void);
        
        DataObject(const int size, const int type);
        
        DataObject(const int sizeY, const int sizeX, const int type);
        
        DataObject(const int sizeZ, const int sizeY, const int sizeX, const int type, const unsigned char continuous = 0);
        
        DataObject(const int sizeZ, const int sizeY, const int sizeX, const int type, const uchar* continuousDataPtr,  const int* steps = NULL);

        DataObject(const MSize &sizes, const int type, const unsigned char continuous = 0);
        
        DataObject(const unsigned char dimensions, const int *sizes, const int type, const unsigned char continuous = 0);
        
        DataObject(const unsigned char dimensions, const int *sizes, const int type, const uchar* continuousDataPtr, const int* steps = NULL);
        
        DataObject(const unsigned char dimensions, const int *sizes, const int type, const cv::Mat* planes, const unsigned int nrOfPlanes);

        DataObject(const cv::Mat &data);
        
        DataObject(const DataObject& copyConstr);    
        ~DataObject(void);
        
        // TAGSPACEFUNCTIONS
        
        double getValueOffset() const;
        
        double getValueScale() const;
        
        const std::string getValueUnit() const;
        
        std::string getValueDescription() const;
        
        double getAxisOffset(const int axisNum) const;
        
        double getAxisScale(const int axisNum) const;
        
        const std::string getAxisUnit(const int axisNum, bool &validOperation) const;
        
        std::string getAxisDescription(const int axisNum, bool &validOperation) const;
        
        DataObjectTagType getTag(const std::string &key, bool &validOperation) const;
        
        bool getTagByIndex(const int tagNumber, std::string &key, DataObjectTagType &value) const;
        
        std::string getTagKey(const int tagNumber, bool &validOperation) const;
        
        int getTagListSize() const;
        
        int setValueUnit(const std::string &unit);
        
        int setValueDescription(const std::string &description);
        
        int setAxisOffset(const unsigned int axisNum, const double offset); 

        int setAxisScale(const unsigned int axisNum, const double scale);

        int setAxisUnit(const unsigned int axisNum, const std::string &unit);

        int setAxisDescription(const unsigned int axisNum, const std::string &description);
        int setTag(const std::string &key, const DataObjectTagType &value);
        bool existTag(const std::string &key) const;
        bool deleteTag(const std::string &key);
        bool deleteAllTags();
        int addToProtocol(const std::string &value);
        
        double getPhysToPix(const unsigned int dim, const double phys, bool &isInsideImage) const;

        double getPhysToPix(const unsigned int dim, const double phys) const;
        
        int getPhysToPix2D(const double physY, double &tPxY, bool &isInsideImageY, const double physX, double &tPxX, bool &isInsideImageX) const;
        
        double getPixToPhys(const unsigned int dim, const double pix, bool &isInsideImage) const;

        double getPixToPhys(const unsigned int dim, const double pix) const;
        
        RetVal setXYRotationalMatrix(double r11, double r12, double r13, double r21, double r22, double r23, double r31, double r32, double r33);
        
        RetVal getXYRotationalMatrix(double &r11, double &r12, double &r13, double &r21, double &r22, double &r23, double &r31, double &r32, double &r33) const;
        
        RetVal copyTagMapTo(DataObject &rhs) const;  
        RetVal copyAxisTagsTo(DataObject &rhs) const;  
                RetVal setReal(DataObject &valuesObj); /*change the real part of a complex data object*/
                RetVal setImag(DataObject &valuesObj); /*change the imaginary part of a complex data object*/
        
        // END TAGSPACE
        
        inline int getDims(void) const { return m_dims; }
        
        inline int getType(void) const { return m_type; }
        
        inline char getContinuous(void) const { return m_continuous; }
        
        inline char getOwnData(void) const { return m_owndata; }
        
        int seekMat(const int matNum, const int numMats) const;
        
        int seekMat(const int matNum) const;
        
        int calcNumMats(void) const;
        

        inline int getNumPlanes(void) const
        {
            switch (m_dims)
            {
                case 0:
                    return 0;
                case 1:
                case 2:
                    return 1;
                case 3:
                    return m_size[0];
                case 4:
                    return m_size[0] * m_size[1];
                default:
                {
                    int numMat = 1;
                    for (int n = 0; n < m_dims - 2; n++)
                    {
                        numMat *= m_size[n];
                    }
                    return numMat;
                }
            }
        }
        
        cv::Mat* getCvPlaneMat(const int planeIndex);
        
        const cv::Mat* getCvPlaneMat(const int planeIndex) const;

        const cv::Mat getContinuousCvPlaneMat(const int planeIndex) const;
        

        inline cv::Mat** get_mdata(void)
        {
            return (cv::Mat**)m_data;
        }
        

        inline const cv::Mat** get_mdata(void) const
        {
            return (const cv::Mat**)m_data;
        }
        

        inline MSize getSize(void) { return m_size; }
        

        inline const MSize getSize(void) const { return m_size; }
        

        inline int getSize(int index) const
        {
            if(index < 0 || index >= m_dims)
            {
                return -1;
            }
            else
            {
                return m_size[index];
            }
        }


        inline MSize getOriginalSize(void) { return m_osize; }


        inline const MSize getOriginalSize(void) const { return m_osize; }
        

        inline int getOriginalSize(int index) const
        {
            if(index < 0 || index >= m_dims)
            {
                return -1;
            }
            else
            {
                return m_osize[index];
            }
        }


        int getStep(int index) const;

        

        inline int getTotal() const
        {
            int dims = getDims();
            int total = dims > 0 ? 1 : 0;
            for(int i = 0 ; i < dims ; i++)
            {
                total *= m_size[i];
            }
            return total;
            
        }
        

        inline int getOriginalTotal() const
        {
            int dims = getDims();
            int total = dims > 0 ? 1 : 0;
            for(int i = 0 ; i<dims ; i++)
            {
                total *= m_osize[i];
            }
            return total;
        }
        
        RetVal copyTo(DataObject &rhs, unsigned char regionOnly = 0) const;   
        RetVal convertTo(DataObject &rhs, const int type, const double alpha=1, const double beta=0 ) const; 
        RetVal setTo(const int8 &value, const DataObject &mask = DataObject());        
        RetVal setTo(const uint8 &value, const DataObject &mask = DataObject());       
        RetVal setTo(const int16 &value, const DataObject &mask = DataObject());       
        RetVal setTo(const uint16 &value, const DataObject &mask = DataObject());      
        RetVal setTo(const int32 &value, const DataObject &mask = DataObject());       
        RetVal setTo(const uint32 &value, const DataObject &mask = DataObject());      
        RetVal setTo(const float32 &value, const DataObject &mask = DataObject());     
        RetVal setTo(const float64 &value, const DataObject &mask = DataObject());     
        RetVal setTo(const complex64 &value, const DataObject &mask = DataObject());   
        RetVal setTo(const complex128 &value, const DataObject &mask = DataObject());  
        RetVal setTo(const ito::Rgba32 &value, const DataObject &mask = DataObject()); 
        RetVal deepCopyPartial(DataObject &copyTo);
        
        DObjIterator begin();
        DObjIterator end();
        
        DObjConstIterator constBegin() const;
        
        DObjConstIterator constEnd() const;
        
        DataObject & operator = (const cv::Mat &rhs);
        DataObject & operator = (const DataObject &rhs);
        DataObject & operator = (const int8 &value);          
        DataObject & operator = (const uint8 &value);         
        DataObject & operator = (const int16 &value);         
        DataObject & operator = (const uint16 &value);        
        DataObject & operator = (const int32 &value);         
        DataObject & operator = (const uint32 &value);        
        DataObject & operator = (const float32 &value);       
        DataObject & operator = (const float64 &value);       
        DataObject & operator = (const complex64 &value);     
        DataObject & operator = (const complex128 &value);    
        DataObject & operator = (const ito::Rgba32 &value);   
        DataObject & operator += (const DataObject &rhs);
        DataObject & operator += (const float64 &value);
        DataObject & operator += (const complex128 &value);
        
        DataObject operator + (const DataObject &rhs);
        DataObject operator + (const float64 &value);
        DataObject operator + (const complex128 &value);
        
        DataObject & operator -= (const DataObject &rhs);
        DataObject & operator -= (const float64 &value);
        DataObject & operator -= (const complex128 &value);
        
        DataObject operator - (const DataObject &rhs);
        DataObject operator - (const float64 &value);
        DataObject operator - (const complex128 &value);
        
        DataObject & operator *= (const DataObject &rhs);
        DataObject & operator *= (const float64 &factor);
        DataObject & operator *= (const complex128 &factor);
        
        DataObject operator * (const DataObject &rhs);
        DataObject operator * (const float64 &factor);
        DataObject operator * (const complex128 &factor);
        
        // Comparison Operators
        DataObject operator < (DataObject &rhs);
        DataObject operator > (DataObject &rhs);
        DataObject operator <= (DataObject &rhs);
        DataObject operator >= (DataObject &rhs);
        DataObject operator == (DataObject &rhs);
        DataObject operator != (DataObject &rhs);
        
        DataObject operator < (const float64 &value);
        DataObject operator > (const float64 &value);
        DataObject operator <= (const float64 &value);
        DataObject operator >= (const float64 &value);
        DataObject operator == (const float64 &value);
        DataObject operator != (const float64 &value);

        DataObject operator == (const ito::complex64 &value);
        DataObject operator != (const ito::complex64 &value);
        DataObject operator == (const ito::complex128 &value);
        DataObject operator != (const ito::complex128 &value);
        
        // bitshift operators
        DataObject operator << (const unsigned int shiftbit);
        DataObject & operator <<= (const unsigned int shiftbit);
        DataObject operator >> (const unsigned int shiftbit);
        DataObject & operator >>= (const unsigned int shiftbit);
        
        // bitwise operators
        DataObject operator & (const DataObject & rhs);
        DataObject & operator &= (const DataObject & rhs);
        DataObject operator | (const DataObject & rhs);
        DataObject & operator |= (const DataObject & rhs);
        DataObject operator ^ (const DataObject & rhs);
        DataObject & operator ^= (const DataObject & rhs);
        DataObject bitwise_not() const; 
        // allocates matrix with zero values
        RetVal zeros(const int type);
        RetVal zeros(const int size, const int type);
        RetVal zeros(const int sizeY, const int sizeX, const int type);
        RetVal zeros(const int sizeZ, const int sizeY, const int sizeX, const int type, const unsigned char continuous = 0);
        RetVal zeros(const unsigned char dimensions, const int *sizes, const int type, const unsigned char continuous = 0);
        
        // allocates matrix with all values set to one
        RetVal ones(const int type);
        RetVal ones(const int size, const int type);
        RetVal ones(const int sizeY, const int sizeX, const int type);
        RetVal ones(const int sizeZ, const int sizeY, const int sizeX, const int type, const unsigned char continuous = 0);
        RetVal ones(const unsigned char dimensions, const int *sizes, const int type, const unsigned char continuous = 0);

                // allocates matrix with all values set to one
                RetVal nans(const int type);
                RetVal nans(const int size, const int type);
                RetVal nans(const int sizeY, const int sizeX, const int type);
                RetVal nans(const int sizeZ, const int sizeY, const int sizeX, const int type, const unsigned char continuous = 0);
                RetVal nans(const unsigned char dimensions, const int *sizes, const int type, const unsigned char continuous = 0);
        
        // allocates matrix with uniform distributed noise
        RetVal rand(const int type, const bool randMode = false);
        RetVal rand(const int size, const int type, const bool randMode = false);
        RetVal rand(const int sizeY, const int sizeX, const int type, const bool randMode = false);
        RetVal rand(const int sizeZ, const int sizeY, const int sizeX, const int type, const bool randMode, const unsigned char continuous = 0);
        RetVal rand(const unsigned char dimensions, const int *sizes, const int type, const bool randMode, const unsigned char continuous = 0);
        
        // allocates matrix with eye-matrix representation
        RetVal eye(const int type);
        RetVal eye(const int size, const int type);
        
        RetVal conj();
        DataObject adj() const;
        DataObject trans() const;
        
        // element-wise multiplication 
        DataObject mul(const DataObject &mat2, const double scale = 1.0) const;
        DataObject div(const DataObject &mat2, const double scale = 1.0) const;

        

                // power (power of 0.5 is the square root)
                DataObject pow(const ito::float64 &power); // returns a new data object with the same size and type than this data object and calculates src**power if power is an integer, else |src|**power (only for float32 and float64 data objects)
                void pow(const ito::float64 &power, DataObject &dst); // this function raises every element of this data object to *power* and saves the result in dst. Dst must be of the same size and type than this data object or empty. In the latter case, it is reassigned to the right size and type.

                DataObject sqrt(); // returns a new data object of the same size and type than this data object where the square root of every element is calculated. Is the same than pow(0.5)
                void sqrt(DataObject &dst); // this function calculates the square root of every element and saves the result in dst. Dst must be of the same size and type than this data object or empty. In the latter case, it is reassigned to the right size and type.. Is the same than pow(0.5, dst)

        DataObject squeeze() const;
        DataObject reshape(int newDims, const int *newSizes) const;

        int elemSize() const;  

        template<typename _Tp> inline const _Tp& at(const unsigned int y, const unsigned int x) const
        {
#if __ITODEBUG
            if (m_dims != 2)
            {
                cv::error(cv::Exception(CV_StsAssert, "Dimension mismatch while addressing data field", "", __FILE__, __LINE__));
            }
            else if (((int)x >= m_size[1]) || ((int)y >= m_size[0]) )
            {
                cv::error(cv::Exception(CV_StsAssert, "Index out of bounds", "", __FILE__ , __LINE__));
            }
#endif
            return (*reinterpret_cast<const cv::Mat_<_Tp>*>(m_data[0]))(y, x);
        }
        

        template<typename _Tp> inline _Tp& at(const unsigned int y, const unsigned int x)
        {
#if __ITODEBUG
            if (m_dims != 2)
            {
                cv::error(cv::Exception(CV_StsAssert, "Dimension mismatch while addressing data field", "", __FILE__, __LINE__));
            }
            else if (((int)x >= m_size[1]) || ((int)y >= m_size[0]) )
            {
                cv::error(cv::Exception(CV_StsAssert, "Index out of bounds", "", __FILE__ , __LINE__));
            }
#endif
            return (*reinterpret_cast<cv::Mat_<_Tp>*>(m_data[0]))(y, x);
        }
        

        template<typename _Tp> inline const _Tp& at(const unsigned int z, const unsigned int y, const unsigned int x) const
        {
#if __ITODEBUG
            if (m_dims != 3)
            {
                cv::error(cv::Exception(CV_StsAssert, "Dimension mismatch while addressing data field", "", __FILE__, __LINE__));
            }
            else if (((int)x >= m_size[2]) || ((int)y >= m_size[1]) || (((int)z + m_roi[0]) >= (m_roi[0] + m_size[0])))
            {
                cv::error(cv::Exception(CV_StsAssert, "Index out of bounds", "", __FILE__ , __LINE__));
            }
#endif
            return (*reinterpret_cast<const cv::Mat_<_Tp>*>(m_data[z + m_roi[0]]))(y, x);
        }
        

        template<typename _Tp> inline _Tp& at(const unsigned int z, const unsigned int y, const unsigned int x)
        {
#if __ITODEBUG
            if (m_dims != 3)
            {
                cv::error(cv::Exception(CV_StsAssert, "Dimension mismatch while addressing data field", "", __FILE__, __LINE__));
            }
            else if (((int)x >= m_size[2]) || ((int)y >= m_size[1]) || (((int)z + m_roi[0]) >= (m_roi[0] + m_size[0])))
            {
                cv::error(cv::Exception(CV_StsAssert, "Index out of bounds", "", __FILE__ , __LINE__));
            }
#endif
            return (*reinterpret_cast<cv::Mat_<_Tp>*>(m_data[z + m_roi[0]]))(y, x);
        }
        

        template<typename _Tp> inline const _Tp& at(const unsigned int *idx) const //idx is in virtual order
        {
            int matNum = 0;
            matIdxToNum(idx, &matNum);
            return (*reinterpret_cast<const cv::Mat_<_Tp>*>(m_data[matNum]))(idx[m_dims - 2], idx[m_dims - 1]);
        }
        

        template<typename _Tp> inline _Tp& at(const unsigned int *idx) //idx is in virtual order
        {
            int matNum = 0;
            matIdxToNum(idx, &matNum);
            return (*reinterpret_cast<cv::Mat_<_Tp>*>(m_data[matNum]))(idx[m_dims - 2], idx[m_dims - 1]);
        }
        
        DataObject at(const ito::Range &rowRange, const ito::Range &colRange) const;    
        DataObject at(ito::Range *ranges) const;                                        
        DataObject at(const DataObject &mask) const;                                    

        inline uchar* rowPtr(const int matNum, const int y)
        {
            int matIndex = seekMat(matNum);
            return ((cv::Mat*)m_data[matIndex])->ptr(y);
        }
        

        inline const uchar* rowPtr(const int matNum, const int y) const
        {
            int matIndex = seekMat(matNum);
            return ((const cv::Mat*)m_data[matIndex])->ptr(y);
        }


        template<typename _Tp> inline _Tp* rowPtr(const int matNum, const int y)
        {
            int matIndex = seekMat(matNum);
            return ((cv::Mat*)m_data[matIndex])->ptr<_Tp>(y);
        }
        

        template<typename _Tp> inline const _Tp* rowPtr(const int matNum, const int y) const
        {
            int matIndex = seekMat(matNum);
            return ((const cv::Mat*)m_data[matIndex])->ptr<_Tp>(y);
        }
        
        DataObject row(const int selRow) const;
        DataObject col(const int selCol) const;
        
        DataObject toGray(const int destinationType = ito::tUInt8) const;
        DataObject splitColor(const char* destinationColor, const int& dtype) const;
                DataObject lineCut(const double* coordinates, const int& len) const;
        
        // ROI
        DataObject & adjustROI(const int dtop, const int dbottom, const int dleft, const int dright);   
        DataObject & adjustROI(const unsigned char dims, const int *lims);                              
        RetVal locateROI(int *wholeSizes, int *offsets) const;                                          
        RetVal locateROI(int *lims) const;                                                              

        template<typename _Tp> RetVal copyFromData2D(const _Tp* src, const int sizeX, const int sizeY) { return copyFromData2DInternal((const uchar*)src, sizeof(_Tp), sizeX, sizeY); }        // copies 2D continuous data into data object, data object must have correct size and type, otherwise an error is returned
        

        template<typename _Tp> RetVal copyFromData2D(const _Tp *src, const int sizeX, const int sizeY, const int x0, const int y0, const int width, const int height) { return copyFromData2DInternal((const uchar*)src, sizeof(_Tp), sizeX, x0, y0, width, height); }      // copies 2D continuous data into data object, data object must have correct size and type, otherwise an error is returned
        
        template<typename T2> operator T2 ();  
        template<typename _Tp> RetVal linspace(const _Tp start, const _Tp end, const _Tp inc, const int transposed);


                static DataObject stack(const DataObject *mats, int num, unsigned int axis = 0);
        
    };
    
    //template<> DATAOBJ_EXPORT RetVal ito::DataObject::linspace<ito::int8>(const ito::int8 /*start*/, const ito::int8 /*end*/, const ito::int8 /*inc*/, const int /*transposed*/);
    //template<> DATAOBJ_EXPORT RetVal ito::DataObject::linspace<ito::uint8>(const ito::uint8 /*start*/, const ito::uint8 /*end*/, const ito::uint8 /*inc*/, const int /*transposed*/);
    
    
    //----------------------------------------------------------------------------------------------------------------------------------
    // functions for DataObject in namespace ITO, which are NOT member functions
    //----------------------------------------------------------------------------------------------------------------------------------
    DATAOBJ_EXPORT DataObject abs(const DataObject &dObj);              
    DATAOBJ_EXPORT DataObject arg(const DataObject &dObj);              
    DATAOBJ_EXPORT DataObject real(const DataObject &dObj);             
    DATAOBJ_EXPORT DataObject imag(const DataObject &dObj);             
    DATAOBJ_EXPORT DataObject makeContinuous(const DataObject &dObj);   

    template<typename _Tp> inline _Tp numberConversion(ito::tDataType fromType, const void *scalar)
    {
        _Tp retValue;
        
        switch(fromType)
        {
            case ito::tUInt8:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const uint8*>(scalar)));
                break;
            case ito::tInt8:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const int8*>(scalar)));
                break;
            case ito::tUInt16:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const uint16*>(scalar)));
                break;
            case ito::tInt16:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const int16*>(scalar)));
                break;
            case ito::tUInt32:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const uint32*>(scalar)));
                break;
            case ito::tInt32:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const int32*>(scalar)));
                break;
            case ito::tFloat32:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const ito::float32*>(scalar)));
                break;
            case ito::tFloat64:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const ito::float64*>(scalar)));
                break;
            case ito::tComplex64:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const ito::complex64*>(scalar)));
                break;
            case ito::tComplex128:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const ito::complex128*>(scalar)));
                break;
            case ito::tRGBA32:
                retValue = cv::saturate_cast<_Tp>(*(static_cast<const ito::Rgba32*>(scalar)));
                break;
            default:
                cv::error(cv::Exception(CV_StsAssert, "Input value type unkown", "", __FILE__, __LINE__));
                retValue = 0;
        }
        
        return retValue;
    };    
    
    DATAOBJ_EXPORT std::ostream& operator << (std::ostream& out, const DataObject& dObj);
    

    inline ito::tDataType convertCmplxTypeToRealType(ito::tDataType cmplxType)
    {
        switch(cmplxType)
        {
            case ito::tInt8:
            case ito::tUInt8:
            case ito::tInt16:
            case ito::tUInt16:
            case ito::tInt32:
            case ito::tUInt32:
            case ito::tFloat32:
            case ito::tFloat64:
            case ito::tRGBA32:
                return cmplxType;
            case ito::tComplex64:
                return ito::tFloat32;
            case ito::tComplex128:
                return ito::tFloat64;
        }
        
        cv::error(cv::Exception(CV_StsAssert, "Input data type unknown", "", __FILE__, __LINE__));
        return ito::tInt8;
    }
    

    inline ito::tDataType guessDataTypeFromCVMat(const cv::Mat* mat, ito::RetVal &retval)
    {
        if (mat)
        {
            switch(mat->type())
            {
                case cv::DataType<ito::int8>::type:
                    return ito::tInt8;
                case cv::DataType<ito::uint8>::type:
                    return ito::tUInt8;
                case cv::DataType<ito::int16>::type:
                    return ito::tInt16;
                case cv::DataType<ito::uint16>::type:
                    return ito::tUInt16;
                case cv::DataType<ito::int32>::type:
                    return ito::tInt32;
                case cv::DataType<ito::uint32>::type:
                    return ito::tUInt32;
                case cv::DataType<ito::float32>::type:
                    return ito::tFloat32;
                case cv::DataType<ito::float64>::type:
                    return ito::tFloat64;
                case cv::DataType<ito::Rgba32>::type:
                    return ito::tRGBA32;
                case cv::DataType<ito::complex64>::type:
                    return ito::tComplex64;
                case cv::DataType<ito::complex128>::type:
                    return ito::tComplex128;
            }
            
            retval += ito::RetVal(ito::retError, 0, "type of cv::Mat is incompatible to ito::DataObject");
        }
        else
        {
            retval += ito::RetVal(ito::retError, 0, "given cv::Mat is NULL.");
        }
        return ito::tInt8;
    }
    
    

    template<typename _Tp> inline ito::tDataType getDataType(const _Tp* /*src*/)
    {
        cv::error(cv::Exception(CV_StsAssert, "Input value type unkown", "", __FILE__, __LINE__));
        return ito::tInt8;
    }
    
    template<> inline ito::tDataType getDataType(const uint8* /*src*/)      { return ito::tUInt8; }
    template<> inline ito::tDataType getDataType(const int8* /*src*/)       { return ito::tInt8; }
    template<> inline ito::tDataType getDataType(const uint16* /*src*/)     { return ito::tUInt16; }
    template<> inline ito::tDataType getDataType(const int16* /*src*/)      { return ito::tInt16; }
    template<> inline ito::tDataType getDataType(const uint32* /*src*/)     { return ito::tUInt32; }
    template<> inline ito::tDataType getDataType(const int32* /*src*/)      { return ito::tInt32; }
    template<> inline ito::tDataType getDataType(const float32* /*src*/)    { return ito::tFloat32; }
    template<> inline ito::tDataType getDataType(const float64* /*src*/)    { return ito::tFloat64; }
    template<> inline ito::tDataType getDataType(const complex64* /*src*/)  { return ito::tComplex64; }
    template<> inline ito::tDataType getDataType(const complex128* /*src*/) { return ito::tComplex128; }
    template<> inline ito::tDataType getDataType(const Rgba32* /*src*/) { return ito::tRGBA32; }
    
    

    template<typename _Tp> inline ito::tDataType getDataType2()
    {
        cv::error(cv::Exception(CV_StsAssert, "Input value type unkown", "", __FILE__, __LINE__));
        return ito::tInt8;
    }
    
    template<> inline ito::tDataType getDataType2<uint8*>()      { return ito::tUInt8; }
    template<> inline ito::tDataType getDataType2<int8*>()       { return ito::tInt8; }
    template<> inline ito::tDataType getDataType2<uint16*>()     { return ito::tUInt16; }
    template<> inline ito::tDataType getDataType2<int16*>()      { return ito::tInt16; }
    template<> inline ito::tDataType getDataType2<uint32*>()     { return ito::tUInt32; }
    template<> inline ito::tDataType getDataType2<int32*>()      { return ito::tInt32; }
    template<> inline ito::tDataType getDataType2<float32*>()    { return ito::tFloat32; }
    template<> inline ito::tDataType getDataType2<float64*>()    { return ito::tFloat64; }
    template<> inline ito::tDataType getDataType2<complex64*>()  { return ito::tComplex64; }
    template<> inline ito::tDataType getDataType2<complex128*>() { return ito::tComplex128; }
    template<> inline ito::tDataType getDataType2<Rgba32*>()     { return ito::tRGBA32; }  
    
} //namespace ito

#endif //__DATAOBJH