D:/git-itom/sources/itom/DataObject/dataObjectFuncs.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2013, Institut für Technische Optik (ITO),
    Universität 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 für 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 __DATAOBJFUNCH
#define __DATAOBJFUNCH

#include "dataobj.h"
#include <assert.h>     /* assert */

#define MAKEHELPERFUNCLIST(FuncName) static t##FuncName fList##FuncName[] = \
{                                                                           \
   FuncName<int8>,                                                          \
   FuncName<uint8>,                                                         \
   FuncName<int16>,                                                         \
   FuncName<uint16>,                                                        \
   FuncName<int32>,                                                         \
   FuncName<uint32>,                                                        \
   FuncName<ito::float32>,                                                  \
   FuncName<ito::float64>,                                                  \
   FuncName<ito::complex64>,                                                \
   FuncName<ito::complex128>,                                               \
   FuncName<ito::Rgba32>                                                    \
};

#define MAKEHELPERFUNCLIST_CMPLX_TO_REAL(FuncName) static t##FuncName fList##FuncName[] = \
{                                                                                         \
    FuncName<ito::complex64,float32>,                                                     \
    FuncName<ito::complex128,float64>                                                     \
};

namespace ito 
{
namespace dObjHelper
{
    enum CmplxSelectionFlags
    {
        CMPLX_ABS_VALUE         = 0,
        CMPLX_IMAGINARY_VALUE   = 1,
        CMPLX_REAL_VALUE        = 2,
        CMPLX_ARGUMENT_VALUE    = 3
    };

    // Invert the unitString
    inline std::string invertUnit(const std::string &oldUnit)
    {
        if(oldUnit.empty())
            return oldUnit;

        int found = (int)oldUnit.find('/');

        if(found!=std::string::npos)
        {
            if(found == 0)
            {
                return oldUnit.substr(1, oldUnit.length() - 1);
            }
            else if(oldUnit[0] == '1' && found == 1)
            {
                return oldUnit.substr(2, oldUnit.length() - 2);
            }
            else
            {
                std::string newString;
                newString.reserve(oldUnit.length());
                newString.append(oldUnit.substr(found + 1, oldUnit.length()- (found + 1)));
                newString.append("/");
                newString.append(oldUnit.substr(0, found));
            }
        }
        else
        {
            std::string newString;
            newString.reserve(oldUnit.length()+2);
            newString.append("1/");
            newString.append(oldUnit);
            return newString;    
        }
        return "";
    }

    //----------------------------------------------------------------------------------------------------------------------------------
    inline int itomType2cvType(const int type)
    {
        switch(type)
        {
        case ito::tUInt8:
            return CV_8U;
        case ito::tUInt16:
            return CV_16U;
        case ito::tInt8:
            return CV_8S;
        case ito::tInt16:
            return CV_16S;
        case ito::tInt32:
            return CV_32S;
        case ito::tFloat32:
            return CV_32F;
        case ito::tFloat64:
            return CV_64F;
        default:    //ito::tUInt32 and complextype
            return -1;
        }
    }
    //----------------------------------------------------------------------------------------------------------------------------------
    inline int cvType2itomType(const int type)
    {
        switch(type)
        {
        case CV_8U:
            return ito::tUInt8;
        case CV_16U:
            return ito::tUInt16;
        case CV_8S:
            return ito::tInt8;
        case CV_16S:
            return ito::tInt16;
        case CV_32S:
            return ito::tInt32;
        case CV_32F:
            return ito::tFloat32;
        case CV_64F:
            return ito::tFloat64;
        default:
            return -1;
        }
    }

    template<typename _Tp> void GetHLineL(const cv::Mat *srcPlane, const int x0, const int y, const int length, int32 * pData);

    template<typename _Tp> void GetHLineD(const cv::Mat *srcPlane, const int x0, const int y, const int length, float64 * pData);

    template<typename _Tp> void GetHLineC(const cv::Mat *srcPlane, const int x0, const int y, const int length, complex128 * pData);

    template<typename _Tp> void SetHLineL(cv::Mat *destPlane, const int x0, const int y, const int length, const int32 * pData);

    template<typename _Tp> void SetHLineD(cv::Mat *destPlane, const int x0, const int y, const int length, const float64 * pData);

//-----------------------------------------------------------------------------------------------
    template<typename _Tp> inline void GetHLineL(const cv::Mat *srcPlane, const int x0, const int y, const int length, int32 * pData)
    {
        _Tp* resRowPtr;
        resRowPtr = (_Tp*)(srcPlane->ptr(y));

        int x = x0;
        for(int i = 0; i < length; i++, x++)
        {
            pData[i] = (int32)(resRowPtr[x]);
        }
    }

    //-----------------------------------------------------------------------------------------------
    template<> inline void GetHLineL<int32>(const cv::Mat *srcPlane, const int x0, const int y, const int length, int32 * pData)
    {
        int32* resRowPtr;
        resRowPtr = (int32*)(srcPlane->ptr(y));
        memcpy(pData, &resRowPtr[x0], length *sizeof(int32));
    }

    //-----------------------------------------------------------------------------------------------
    template<typename _Tp> inline void GetHLineD(const cv::Mat *srcPlane, const int x0, const int y, const int length, float64 * pData)
    {
        _Tp* resRowPtr;
        resRowPtr = (_Tp*)(srcPlane->ptr(y));

        int x = x0;
        for(int i = 0; i < length; i++, x++)
        {
            pData[i] = cv::saturate_cast<ito::float64>(resRowPtr[x]);
        }
    }

    //-----------------------------------------------------------------------------------------------
    template<> inline void GetHLineD<ito::float64>(const cv::Mat *srcPlane, const int x0, const int y, const int length, float64 * pData)
    {
        float64* resRowPtr;
        resRowPtr = (float64*)(srcPlane->ptr(y));
        memcpy(pData, &resRowPtr[x0], length *sizeof(float64));
    }

        //-----------------------------------------------------------------------------------------------
    template<typename _Tp> inline void GetHLineC(const cv::Mat *srcPlane, const int x0, const int y, const int length, complex128 * pData)
    {
        const _Tp* resRowPtr = srcPlane->ptr<_Tp>(y);

        int x = x0;
        for(int i = 0; i < length; i++, x++)
        {
            pData[i] = complex128(cv::saturate_cast<ito::float64>(resRowPtr[x]), 0.0);
        }
    }

    //-----------------------------------------------------------------------------------------------
    template<> inline void GetHLineC<complex64>(const cv::Mat *srcPlane, const int x0, const int y, const int length, complex128 * pData)
    {
        const complex64* resRowPtr = srcPlane->ptr<complex64>(y);

        int x = x0;
        for(int i = 0; i < length; i++, x++)
        {
            pData[i] = complex128(resRowPtr[x].real(), resRowPtr[x].imag());
        }
    }

    //-----------------------------------------------------------------------------------------------
    template<> inline void GetHLineC<complex128>(const cv::Mat *srcPlane, const int x0, const int y, const int length, complex128 * pData)
    {
        const complex128* resRowPtr = srcPlane->ptr<complex128>(y);
        memcpy(pData, &resRowPtr[x0], length *sizeof(complex128));
    }

    //-----------------------------------------------------------------------------------------------
    template<typename _Tp> inline void SetHLineL(cv::Mat *destPlane, const int x0, const int y, const int length, const int32 * pData)
    {
        _Tp* resRowPtr;
        resRowPtr = (_Tp*)(destPlane->ptr(y));

        int x = x0;
        for(int i = 0; i < length; i++, x++)
        {
            resRowPtr[x] = (_Tp)(pData[i]);
        }
    }

    //-----------------------------------------------------------------------------------------------
    template<> inline void SetHLineL<int32>(cv::Mat *destPlane, const int x0, const int y, const int length, const int32 * pData)
    {
        int32* resRowPtr;
        resRowPtr = (int32*)(destPlane->ptr(y));
        memcpy(&resRowPtr[x0], pData, length *sizeof(int32));
    }

    //-----------------------------------------------------------------------------------------------
    template<typename _Tp> inline void SetHLineD(cv::Mat *destPlane, const int x0, const int y, const int length, const float64 * pData)
    {
        _Tp* resRowPtr;
        resRowPtr = (_Tp*)destPlane->ptr(y);

        int x = x0;
        for(int i = 0; i < length; i++, x++)
        {
            resRowPtr[x] = cv::saturate_cast<_Tp>(pData[i]);
        }
    }

    //-----------------------------------------------------------------------------------------------
    template<> inline void SetHLineD<ito::float64>(cv::Mat *destPlane, const int x0, const int y, const int length, const float64 * pData)
    {
        float64* resRowPtr;
        resRowPtr = (float64*)(destPlane->ptr(y));
        memcpy(&resRowPtr[x0], pData, length *sizeof(float64));
    }

    template<typename _Tp> inline bool isNotZero(_Tp value)
    {
        if(value == 0)
            return false;
        else
            return true;
    }

    template<> inline bool isNotZero<float32>(float32 value)
    {
        float32 lowVal = std::numeric_limits<float32>::epsilon();
        if(fabs(value) < lowVal)
            return false;
        else
            return true;
    }

    template<> inline bool isNotZero<float64>(float64 value)
    {
        float64 lowVal = std::numeric_limits<float64>::epsilon();
        if(fabs(value) < lowVal)
            return false;
        else
            return true;
    }

    template<typename _Tp> inline bool isFinite(_Tp /*value*/)
    {
        return true;
    }

    template<> inline bool isFinite<float32>(float32 value)
    {
        uchar *ch = (uchar *)&value;
        return (ch[3] & 0x7f) != 0x7f || (ch[2] & 0x80) != 0x80;
    }

    template<> inline bool isFinite<float64>(float64 value)
    {
        uchar *ch = (uchar *)&value;
        return (ch[7] & 0x7f) != 0x7f || (ch[6] & 0xf0) != 0xf0;
    }

    template<> inline bool isFinite<complex64>(complex64 value)
    {
        float32 realVal = value.real();
        float32 imagVal = value.real();
        uchar *chreal = (uchar *)&realVal;
        uchar *chimag = (uchar *)&imagVal;
        return ((chreal[3] & 0x7f) != 0x7f || (chreal[2] & 0x80) != 0x80) && ((chimag[3] & 0x7f) != 0x7f || (chimag[2] & 0x80) != 0x80);
    }

    template<> inline bool isFinite<complex128>(complex128 value)
    {
        float64 realVal = value.real();
        float64 imagVal = value.real();
        uchar *chreal = (uchar *)&realVal;
        uchar *chimag = (uchar *)&imagVal;
        return ((chreal[7] & 0x7f) != 0x7f || (chreal[6] & 0xf0) != 0xf0) && ((chimag[7] & 0x7f) != 0x7f || (chimag[6] & 0xf0) != 0xf0);
    }

    template<typename _Tp> inline bool isNaN(_Tp value)
    {
        return false;
    }

    template<> inline bool isNaN<float32>(float32 value)
    {
        uchar *ch = (uchar *)&value;
        return (ch[3] & 0x7f) == 0x7f && ch[2] > 0x80;
    }
    template<> inline bool isNaN<float64>(float64 value)
    {
        uchar *ch = (uchar *)&value;
        return (ch[7] & 0x7f) == 0x7f && ch[6] > 0xf0;
    }

    template<> inline bool isNaN<complex64>(complex64 value)
    {
        float32 realVal = value.real();
        float32 imagVal = value.real();
        uchar *chreal = (uchar *)&realVal;
        uchar *chimag = (uchar *)&imagVal;
        return ((chreal[3] & 0x7f) == 0x7f && chreal[2] > 0x80) || ((chimag[3] & 0x7f) == 0x7f && chimag[2] > 0x80);
    }

    template<> inline bool isNaN<complex128>(complex128 value)
    {
        float64 realVal = value.real();
        float64 imagVal = value.real();
        uchar *chreal = (uchar *)&realVal;
        uchar *chimag = (uchar *)&imagVal;
        return ((chreal[7] & 0x7f) == 0x7f && chreal[6] > 0xf0) || ((chimag[7] & 0x7f) == 0x7f && chimag[6] > 0xf0);
    }

    template<typename _Tp> inline bool isInf(_Tp /*value*/)
    {
        return false;
    }

    template<> inline bool isInf<float32>(float32 value)
    {
        uchar *ch = (uchar *)&value;
        return (ch[3] & 0x7f) == 0x7f && ch[2] == 0x80;
    }

    template<> inline bool isInf<float64>(float64 value)
    {
        uchar *ch = (uchar *)&value;
        return (ch[7] & 0x7f) == 0x7f && ch[6] == 0xf0;
    }

    template<> inline bool isInf<complex64>(complex64 value)
    {
        float32 realVal = value.real();
        float32 imagVal = value.real();
        uchar *chreal = (uchar *)&realVal;
        uchar *chimag = (uchar *)&imagVal;
        return ((chreal[3] & 0x7f) == 0x7f && chreal[2] == 0x80) || ((chimag[3] & 0x7f) == 0x7f && chimag[2] == 0x80);
    }

    template<> inline bool isInf<complex128>(complex128 value)
    {
        float64 realVal = value.real();
        float64 imagVal = value.real();
        uchar *chreal = (uchar *)&realVal;
        uchar *chimag = (uchar *)&imagVal;
        return ((chreal[7] & 0x7f) == 0x7f && chreal[6] == 0xf0) || ((chimag[7] & 0x7f) == 0x7f && chimag[6] == 0xf0);
    }

    template<typename _Tp> RetVal minValueFunc(const DataObject *dObj, float64 &minValue, uint32 *firstLocation, bool ignoreInf = true);
    
    RetVal DATAOBJ_EXPORT minValue(const DataObject *dObj, float64 &minValue, uint32 *firstLocation, bool ignoreInf = true);
       
    template<typename _Tp> RetVal maxValueFunc(const DataObject *dObj, float64 &maxValue, uint32 *firstLocation, bool ignoreInf = true);

    RetVal DATAOBJ_EXPORT maxValue(const DataObject *dObj, float64 &maxValue, uint32 *firstLocation, bool ignoreInf = true);
        
    template<typename _Tp> RetVal minMaxValueFunc(const DataObject *dObj, float64 &minValue, uint32 *firstMinLocation, float64 &maxValue, uint32 *firstMaxLocation, bool ignoreInf = true, const int specialDataTypeFlags = CMPLX_ABS_VALUE);
    
    RetVal DATAOBJ_EXPORT minMaxValue(const DataObject *dObj, float64 &minValue, uint32 *firstMinLocation, float64 &maxValue, uint32 *firstMaxLocation, bool ignoreInf = true, const int specialDataTypeFlags = CMPLX_ABS_VALUE);

    template<typename _Tp, typename _BufTp> RetVal meanValueFunc(const DataObject *dObj, float64 &meanResult, bool ignoreNaN = true);
    RetVal DATAOBJ_EXPORT meanValue(const DataObject *dObj, float64 &meanResult, bool ignoreNaN = true);

    template<typename _Tp, typename _BufTp> RetVal devValueFunc(const ito::DataObject *dObj, const int devTypFlag, float64 &meanResult, float64 &devResult, bool ignoreNaN = true);
    RetVal DATAOBJ_EXPORT devValue(const DataObject *dObj, const int devTypFlag, float64 &meanResult, float64 &devResult, bool ignoreNaN = true);

    RetVal DATAOBJ_EXPORT calcCVDFT(DataObject *dObjIO, const bool inverse, const bool inverseAsReal, const bool lineWise);

    ito::RetVal DATAOBJ_EXPORT verifyDataObjectType(const ito::DataObject* dObj, const char* name, uint8 numberOfAllowedTypes, ...); //append allowed data types, e.g. ito::tUint8, ito::tInt8... (order does not care)
    
    ito::RetVal DATAOBJ_EXPORT verify2DDataObject(const ito::DataObject* dObj, const char* name, int sizeYMin, int sizeYMax, int sizeXMin, int sizeXMax, uint8 numberOfAllowedTypes, ...); //append allowed data types, e.g. ito::tUint8, ito::tInt8... (order does not care)
    
    //ito::RetVal DATAOBJ_EXPORT verify1PlaneDObject(const ito::DataObject* dObj, const char* name, int &yIdx, int sizeYMin, int sizeYMax, int &xIdx, int sizeXMin, int sizeXMax, uint8 numberOfAllowedTypes, ...); //append allowed data types, e.g. ito::tUint8, ito::tInt8... (order does not care)
    
    ito::RetVal DATAOBJ_EXPORT verify3DDataObject(const ito::DataObject* dObj, const char* name, int sizeZMin, int sizeZMax, int sizeYMin, int sizeYMax, int sizeXMin, int sizeXMax, uint8 numberOfAllowedTypes, ...); //append allowed data types, e.g. ito::tUint8, ito::tInt8... (order does not care)
    
    ito::RetVal DATAOBJ_EXPORT verifySize(int size, int minSize, int maxSize, const char *axisName, const char* dObjName);

    ito::DataObject DATAOBJ_EXPORT squeezeConvertCheck2DDataObject(const ito::DataObject *dObj, const char* name, const ito::Range &sizeY, const ito::Range &sizeX, ito::RetVal &retval, int convertToType, uint8 numberOfAllowedTypes, ...);
    
    //-----------------------------------------------------------------------------------------------
    template<typename _Tp> ito::RetVal freeRowPointer(_Tp *** &pointer)
    {
        if(pointer == NULL)
        {
            return ito::RetVal::format(ito::retError, 0, "Delete rowpointer failed, pointer was not allocated freeRowPointer(...)");
        }

        int i = 0;

        while(pointer[i] != 0)
        {
            free(pointer[i]);
            i++;
            // end of pointer is marked by a NULL-Pointer
        }

        free(pointer);
        pointer = NULL;

        return ito::retOk;
    }

    template<typename _Tp> ito::RetVal getRowPointer(ito::DataObject* dObj, _Tp *** &pointer)  
    {

        if(!dObj)
        {
            return ito::RetVal::format(ito::retError, 0, "DataObject was a NULL pointer in function getRowPointer(...)");               
        }

        if(dObj->getType() != ito::getDataType2<_Tp*>())
        {
            return ito::RetVal::format(ito::retError, 0, "DataObject and template Type differed in function getRowPointer(...)");               
        }

        if(dObj->getDims() < 2)
        {
            return ito::RetVal::format(ito::retError, 0, "DataObject was not initialized in function getRowPointer(...)");   
        }

        pointer = (_Tp***)calloc(dObj->getNumPlanes() + 1, sizeof(_Tp**));

        if(pointer == NULL)
        {
            return ito::RetVal::format(ito::retError, 0, "Allocate plane-pointer failed in function getRowPointer(...)");
        }

        ito::RetVal retVal(ito::retOk);
        int sizeY = dObj->getSize(dObj->getDims() - 2);

        cv::Mat** mdata = dObj->get_mdata();
        int numMats = dObj->getNumPlanes();
        for(int i = 0; i < dObj->getNumPlanes(); i++)
        {
            pointer[i] = (_Tp**)calloc(sizeY, sizeof(_Tp*));
            if(pointer[i])
            {
                for(int y = 0; y < sizeY; y++)
                {
                    pointer[i][y] = mdata[dObj->seekMat(i, numMats)]->ptr<_Tp>(y);
                }
            }
            else
            {
                retVal += ito::RetVal::format(ito::retError, 0, "Allocate row-pointer failed in function getRowPointer(...)");
                break;
            }
        }

        if(retVal.containsError())
        {
            freeRowPointer(pointer);
        }
        return retVal;
    } 
 
    //-----------------------------------------------------------------------------------------------
    inline bool isIntType(const int type, int *size)
    {
        if((type == ito::tInt8)||(type == ito::tUInt8))
        {
            *size = 1;
            return true;
        }
        else if((type == ito::tInt16)||(type == ito::tUInt16))
        {
            *size = 2;
            return true;
        }
        else if((type == ito::tInt32)||(type == ito::tUInt32))
        {
            *size = 4;
            return true;
        }
        else
        {
            *size = -1;
            return false;
        }
    }

    //-----------------------------------------------------------------------------------------------
    inline bool isFPType(const int type, int *size)
    {
        if((type == ito::tFloat32))
        {
            *size = 4;
            return true;
        }
        else if((type == ito::tFloat64))
        {
            *size = 8;
            return true;
        }
        else
        {
            *size = -1;
            return false;
        }
    }

    //-----------------------------------------------------------------------------------------------
    inline bool isCplxType(const int type, int *size)
    {
        if((type == ito::tComplex64))
        {
            *size = 8;
            return true;
        }
        else if((type == ito::tComplex128))
        {
            *size = 16;
            return true;
        }
        else
        {
            *size = -1;
            return false;
        }
    }

    //-----------------------------------------------------------------------------------------------
    inline bool dObjareEqualDetail(const ito::DataObject *dObj1, const ito::DataObject *dObj2, bool &typeFlag, bool &dimsFlag, bool &last2DimsFlag)
    {
        assert(dObj1 && dObj2);

        bool sizeEqual;

        last2DimsFlag = true;

        int d1 = dObj1->getDims();
        int d2 = dObj2->getDims();
        dimsFlag = (d1 == d2);
        typeFlag = (dObj1->getType() == dObj2->getType());

        if(d1 != d2)
        {
            sizeEqual = false;

            if (d1 >= 2 && d2 >= 2)
            {
                if(dObj1->getSize(dObj1->getDims() - 2) != dObj2->getSize(dObj2->getDims() - 2))
                {
                    last2DimsFlag = false;
                }
                else if(dObj1->getSize(dObj1->getDims() - 1) != dObj2->getSize(dObj2->getDims() - 1))
                {
                    last2DimsFlag = false;
                }
            }
            else
            {
                last2DimsFlag = false;
            }
        }
        else
        {
            sizeEqual = (dObj1->getSize() == dObj2->getSize());

            if (d1 >= 2)
            {
                if(dObj1->getSize(dObj1->getDims() - 2) != dObj2->getSize(dObj2->getDims() - 2))
                {
                    last2DimsFlag = false;
                }
                else if(dObj1->getSize(dObj1->getDims() - 1) != dObj2->getSize(dObj2->getDims() - 1))
                {
                    last2DimsFlag = false;
                }
            }
            else
            {
                last2DimsFlag = false;
            }
        }
        return typeFlag && dimsFlag && last2DimsFlag && sizeEqual;
    }

    //-----------------------------------------------------------------------------------------------
    inline bool dObjareEqualShort(const ito::DataObject *obj1, const ito::DataObject *obj2)
    {
        assert(obj1 && obj2);

        return (obj1->getType() == obj2->getType()) && (obj1->getSize() == obj2->getSize());
    }

    ito::RetVal DATAOBJ_EXPORT dObjCopyLastNAxisTags(const ito::DataObject &DataObjectIn, ito::DataObject &DataObjectOut, const int copyLastNDims, const bool includeValueTags = true, const bool includeRotationMatrix = true);

    ito::RetVal DATAOBJ_EXPORT dObjSetScaleRectangle(ito::DataObject &DataObjectInOut, const double &x0, const double &x1, const double &y0, const double &y1);
} //end namespace dObjHelper
} //end namespace ito

#endif