opencv/modules/imgproc/src/accum.cpp

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                           License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
/
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#include "precomp.hpp"

namespace cv
{

inline float sqr(uchar a) { return CV_8TO32F_SQR(a); }
inline float sqr(float a) { return a*a; }
    
inline double sqr(double a) { return a*a; }
    
inline Vec3f sqr(const Vec3b& a)
{
    return Vec3f(CV_8TO32F_SQR(a[0]), CV_8TO32F_SQR(a[1]), CV_8TO32F_SQR(a[2]));
}
inline Vec3f sqr(const Vec3f& a)
{
    return Vec3f(a[0]*a[0], a[1]*a[1], a[2]*a[2]);
}
inline Vec3d sqr(const Vec3d& a)
{
    return Vec3d(a[0]*a[0], a[1]*a[1], a[2]*a[2]);
}   
inline float multiply(uchar a, uchar b) { return CV_8TO32F(a)*CV_8TO32F(b); }
inline float multiply(float a, float b) { return a*b; }
inline double multiply(double a, double b) { return a*b; }    
inline Vec3f multiply(const Vec3b& a, const Vec3b& b)
{
    return Vec3f(
        CV_8TO32F(a[0])*CV_8TO32F(b[0]),
        CV_8TO32F(a[1])*CV_8TO32F(b[1]),
        CV_8TO32F(a[2])*CV_8TO32F(b[2]));
}
inline Vec3f multiply(const Vec3f& a, const Vec3f& b)
{
    return Vec3f(a[0]*b[0], a[1]*b[1], a[2]*b[2]);
}
inline Vec3d multiply(const Vec3d& a, const Vec3d& b)
{
    return Vec3d(a[0]*b[0], a[1]*b[1], a[2]*b[2]);
}
    
inline float addw(uchar a, float alpha, float b, float beta)
{
    return b*beta + CV_8TO32F(a)*alpha;
}
inline float addw(float a, float alpha, float b, float beta)
{
    return b*beta + a*alpha;
}
inline double addw(uchar a, double alpha, double b, double beta)
{
    return b*beta + CV_8TO32F(a)*alpha;
}
inline double addw(float a, double alpha, double b, double beta)
{
    return b*beta + a*alpha;
}
inline double addw(double a, double alpha, double b, double beta)
{
    return b*beta + a*alpha;
}
    
inline Vec3f addw(const Vec3b& a, float alpha, const Vec3f& b, float beta)
{
    return Vec3f(b[0]*beta + CV_8TO32F(a[0])*alpha,
                 b[1]*beta + CV_8TO32F(a[1])*alpha,
                 b[2]*beta + CV_8TO32F(a[2])*alpha);
}
inline Vec3f addw(const Vec3f& a, float alpha, const Vec3f& b, float beta)
{
    return Vec3f(b[0]*beta + a[0]*alpha, b[1]*beta + a[1]*alpha, b[2]*beta + a[2]*alpha);
}
inline Vec3d addw(const Vec3b& a, double alpha, const Vec3d& b, double beta)
{
    return Vec3d(b[0]*beta + CV_8TO32F(a[0])*alpha,
                 b[1]*beta + CV_8TO32F(a[1])*alpha,
                 b[2]*beta + CV_8TO32F(a[2])*alpha);
}
inline Vec3d addw(const Vec3f& a, double alpha, const Vec3d& b, double beta)
{
    return Vec3d(b[0]*beta + a[0]*alpha, b[1]*beta + a[1]*alpha, b[2]*beta + a[2]*alpha);
}
inline Vec3d addw(const Vec3d& a, double alpha, const Vec3d& b, double beta)
{
    return Vec3d(b[0]*beta + a[0]*alpha, b[1]*beta + a[1]*alpha, b[2]*beta + a[2]*alpha);
}    

template<typename T, typename AT> void
acc_( const Mat& _src, Mat& _dst )
{
    Size size = _src.size();
    size.width *= _src.channels();

    if( _src.isContinuous() && _dst.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src = (const T*)(_src.data + _src.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);

        for( j = 0; j <= size.width - 4; j += 4 )
        {
            AT t0 = dst[j] + src[j], t1 = dst[j+1] + src[j+1];
            dst[j] = t0; dst[j+1] = t1;
            t0 = dst[j+2] + src[j+2]; t1 = dst[j+3] + src[j+3];
            dst[j+2] = t0; dst[j+3] = t1;
        }

        for( ; j < size.width; j++ )
            dst[j] += src[j];
    }
}


template<typename T, typename AT> void
accSqr_( const Mat& _src, Mat& _dst )
{
    Size size = _src.size();
    size.width *= _src.channels();

    if( _src.isContinuous() && _dst.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src = (const T*)(_src.data + _src.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);

        for( j = 0; j <= size.width - 4; j += 4 )
        {
            AT t0 = dst[j] + sqr(src[j]), t1 = dst[j+1] + sqr(src[j+1]);
            dst[j] = t0; dst[j+1] = t1;
            t0 = dst[j+2] + sqr(src[j+2]); t1 = dst[j+3] + sqr(src[j+3]);
            dst[j+2] = t0; dst[j+3] = t1;
        }

        for( ; j < size.width; j++ )
            dst[j] += sqr(src[j]);
    }
}


template<typename T, typename AT> void
accProd_( const Mat& _src1, const Mat& _src2, Mat& _dst )
{
    Size size = _src1.size();
    size.width *= _src1.channels();

    if( _src1.isContinuous() && _src2.isContinuous() && _dst.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src1 = (const T*)(_src1.data + _src1.step*i);
        const T* src2 = (const T*)(_src2.data + _src2.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);

        for( j = 0; j <= size.width - 4; j += 4 )
        {
            AT t0, t1;
            t0 = dst[j] + multiply(src1[j], src2[j]);
            t1 = dst[j+1] + multiply(src1[j+1], src2[j+1]);
            dst[j] = t0; dst[j+1] = t1;
            t0 = dst[j+2] + multiply(src1[j+2], src2[j+2]);
            t1 = dst[j+3] + multiply(src1[j+3], src2[j+3]);
            dst[j+2] = t0; dst[j+3] = t1;
        }

        for( ; j < size.width; j++ )
            dst[j] += multiply(src1[j], src2[j]);
    }
}


template<typename T, typename AT> void
accW_( const Mat& _src, Mat& _dst, double _alpha )
{
    AT alpha = (AT)_alpha, beta = (AT)(1 - _alpha);
    Size size = _src.size();
    size.width *= _src.channels();

    if( _src.isContinuous() && _dst.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src = (const T*)(_src.data + _src.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);

        for( j = 0; j <= size.width - 4; j += 4 )
        {
            AT t0, t1;
            t0 = addw(src[j], alpha, dst[j], beta);
            t1 = addw(src[j+1], alpha, dst[j+1], beta);
            dst[j] = t0; dst[j+1] = t1;
            t0 = addw(src[j+2], alpha, dst[j+2], beta);
            t1 = addw(src[j+3], alpha, dst[j+3], beta);
            dst[j+2] = t0; dst[j+3] = t1;
        }

        for( ; j < size.width; j++ )
            dst[j] = addw(src[j], alpha, dst[j], beta);
    }
}


template<typename T, typename AT> void
accMask_( const Mat& _src, Mat& _dst, const Mat& _mask )
{
    Size size = _src.size();

    if( _src.isContinuous() && _dst.isContinuous() && _mask.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src = (const T*)(_src.data + _src.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);
        const uchar* mask = _mask.data + _mask.step*i;

        for( j = 0; j < size.width; j++ )
            if( mask[j] )
                dst[j] += src[j];
    }
}


template<typename T, typename AT> void
accSqrMask_( const Mat& _src, Mat& _dst, const Mat& _mask )
{
    Size size = _src.size();

    if( _src.isContinuous() && _dst.isContinuous() && _mask.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src = (const T*)(_src.data + _src.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);
        const uchar* mask = _mask.data + _mask.step*i;

        for( j = 0; j < size.width; j++ )
            if( mask[j] )
                dst[j] += sqr(src[j]);
    }
}


template<typename T, typename AT> void
accProdMask_( const Mat& _src1, const Mat& _src2, Mat& _dst, const Mat& _mask )
{
    Size size = _src1.size();

    if( _src1.isContinuous() && _src2.isContinuous() &&
        _dst.isContinuous() && _mask.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src1 = (const T*)(_src1.data + _src1.step*i);
        const T* src2 = (const T*)(_src2.data + _src2.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);
        const uchar* mask = _mask.data + _mask.step*i;

        for( j = 0; j < size.width; j++ )
            if( mask[j] )
                dst[j] += multiply(src1[j], src2[j]);
    }
}


template<typename T, typename AT> void
accWMask_( const Mat& _src, Mat& _dst, double _alpha, const Mat& _mask )
{
    typedef typename DataType<AT>::channel_type AT1;
    AT1 alpha = (AT1)_alpha, beta = (AT1)(1 - _alpha);
    Size size = _src.size();

    if( _src.isContinuous() && _dst.isContinuous() && _mask.isContinuous() )
    {
        size.width *= size.height;
        size.height = 1;
    }

    int i, j;
    for( i = 0; i < size.height; i++ )
    {
        const T* src = (const T*)(_src.data + _src.step*i);
        AT* dst = (AT*)(_dst.data + _dst.step*i);
        const uchar* mask = _mask.data + _mask.step*i;

        for( j = 0; j < size.width; j++ )
            if( mask[j] )
                dst[j] = addw(src[j], alpha, dst[j], beta);
    }
}


typedef void (*AccFunc)(const Mat&, Mat&);
typedef void (*AccMaskFunc)(const Mat&, Mat&, const Mat&);
typedef void (*AccProdFunc)(const Mat&, const Mat&, Mat&);
typedef void (*AccProdMaskFunc)(const Mat&, const Mat&, Mat&, const Mat&);
typedef void (*AccWFunc)(const Mat&, Mat&, double);
typedef void (*AccWMaskFunc)(const Mat&, Mat&, double, const Mat&);

void accumulate( const Mat& src, Mat& dst, const Mat& mask )
{
    CV_Assert( dst.size() == src.size() && dst.channels() == src.channels() );

    if( !mask.data )
    {
        AccFunc func = 0;
        if( src.depth() == CV_8U && dst.depth() == CV_32F )
            func = acc_<uchar, float>;
        else if( src.depth() == CV_8U && dst.depth() == CV_64F )
            func = acc_<uchar, double>;
        else if( src.depth() == CV_32F && dst.depth() == CV_32F )
            func = acc_<float, float>;
        else if( src.depth() == CV_32F && dst.depth() == CV_64F )
            func = acc_<float, double>;
        else if( src.depth() == CV_64F && dst.depth() == CV_64F )
            func = acc_<double, double>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src, dst );
    }
    else
    {
        CV_Assert( mask.size() == src.size() && mask.type() == CV_8UC1 );

        AccMaskFunc func = 0;
        if( src.type() == CV_8UC1 && dst.type() == CV_32FC1 )
            func = accMask_<uchar, float>;
        else if( src.type() == CV_8UC3 && dst.type() == CV_32FC3 )
            func = accMask_<Vec3b, Vec3f>;
        else if( src.type() == CV_8UC1 && dst.type() == CV_64FC1 )
            func = accMask_<uchar, double>;
        else if( src.type() == CV_8UC3 && dst.type() == CV_64FC3 )
            func = accMask_<Vec3b, Vec3d>;
        else if( src.type() == CV_32FC1 && dst.type() == CV_32FC1 )
            func = accMask_<float, float>;
        else if( src.type() == CV_32FC3 && dst.type() == CV_32FC3 )
            func = accMask_<Vec3f, Vec3f>;
        else if( src.type() == CV_32FC1 && dst.type() == CV_64FC1 )
            func = accMask_<float, double>;
        else if( src.type() == CV_32FC3 && dst.type() == CV_64FC3 )
            func = accMask_<Vec3f, Vec3d>;
        else if( src.type() == CV_64FC1 && dst.type() == CV_64FC1 )
            func = accMask_<double, double>;
        else if( src.type() == CV_64FC3 && dst.type() == CV_64FC3 )
            func = accMask_<Vec3d, Vec3d>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src, dst, mask );
    }
}


void accumulateSquare( const Mat& src, Mat& dst, const Mat& mask )
{
    CV_Assert( dst.size() == src.size() && dst.channels() == src.channels() );
    
    if( !mask.data )
    {
        AccFunc func = 0;
        if( src.depth() == CV_8U && dst.depth() == CV_32F )
            func = accSqr_<uchar, float>;
        else if( src.depth() == CV_8U && dst.depth() == CV_64F )
            func = accSqr_<uchar, double>;
        else if( src.depth() == CV_32F && dst.depth() == CV_32F )
            func = accSqr_<float, float>;
        else if( src.depth() == CV_32F && dst.depth() == CV_64F )
            func = accSqr_<float, double>;
        else if( src.depth() == CV_64F && dst.depth() == CV_64F )
            func = accSqr_<double, double>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src, dst );
    }
    else
    {
        CV_Assert( mask.size() == src.size() && mask.type() == CV_8UC1 );

        AccMaskFunc func = 0;
        if( src.type() == CV_8UC1 && dst.type() == CV_32FC1 )
            func = accSqrMask_<uchar, float>;
        else if( src.type() == CV_8UC3 && dst.type() == CV_32FC3 )
            func = accSqrMask_<Vec3b, Vec3f>;
        else if( src.type() == CV_8UC1 && dst.type() == CV_64FC1 )
            func = accSqrMask_<uchar, double>;
        else if( src.type() == CV_8UC3 && dst.type() == CV_64FC3 )
            func = accSqrMask_<Vec3b, Vec3d>;
        else if( src.type() == CV_32FC1 && dst.type() == CV_32FC1 )
            func = accSqrMask_<float, float>;
        else if( src.type() == CV_32FC3 && dst.type() == CV_32FC3 )
            func = accSqrMask_<Vec3f, Vec3f>;
        else if( src.type() == CV_32FC1 && dst.type() == CV_64FC1 )
            func = accSqrMask_<float, double>;
        else if( src.type() == CV_32FC3 && dst.type() == CV_64FC3 )
            func = accSqrMask_<Vec3f, Vec3d>;
        else if( src.type() == CV_64FC1 && dst.type() == CV_64FC1 )
            func = accSqrMask_<double, double>;
        else if( src.type() == CV_64FC3 && dst.type() == CV_64FC3 )
            func = accSqrMask_<Vec3d, Vec3d>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src, dst, mask );
    }
}


void accumulateProduct( const Mat& src1, const Mat& src2, Mat& dst, const Mat& mask )
{
    CV_Assert( dst.size() == src1.size() && dst.channels() == src1.channels() &&
               src1.size() == src2.size() && src1.type() == src2.type() );
    
    if( !mask.data )
    {
        AccProdFunc func = 0;
        if( src1.depth() == CV_8U && dst.depth() == CV_32F )
            func = accProd_<uchar, float>;
        else if( src1.depth() == CV_8U && dst.depth() == CV_64F )
            func = accProd_<uchar, double>;
        else if( src1.depth() == CV_32F && dst.depth() == CV_32F )
            func = accProd_<float, float>;
        else if( src1.depth() == CV_32F && dst.depth() == CV_64F )
            func = accProd_<float, double>;
        else if( src1.depth() == CV_64F && dst.depth() == CV_64F )
            func = accProd_<double, double>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src1, src2, dst );
    }
    else
    {
        CV_Assert( mask.size() == src1.size() && mask.type() == CV_8UC1 );

        AccProdMaskFunc func = 0;
        if( src1.type() == CV_8UC1 && dst.type() == CV_32FC1 )
            func = accProdMask_<uchar, float>;
        else if( src1.type() == CV_8UC3 && dst.type() == CV_32FC3 )
            func = accProdMask_<Vec3b, Vec3f>;
        else if( src1.type() == CV_8UC1 && dst.type() == CV_64FC1 )
            func = accProdMask_<uchar, double>;
        else if( src1.type() == CV_8UC3 && dst.type() == CV_64FC3 )
            func = accProdMask_<Vec3b, Vec3d>;
        else if( src1.type() == CV_32FC1 && dst.type() == CV_32FC1 )
            func = accProdMask_<float, float>;
        else if( src1.type() == CV_32FC3 && dst.type() == CV_32FC3 )
            func = accProdMask_<Vec3f, Vec3f>;
        else if( src1.type() == CV_32FC1 && dst.type() == CV_64FC1 )
            func = accProdMask_<float, double>;
        else if( src1.type() == CV_32FC3 && dst.type() == CV_64FC3 )
            func = accProdMask_<Vec3f, Vec3d>;
        else if( src1.type() == CV_64FC1 && dst.type() == CV_64FC1 )
            func = accProdMask_<double, double>;
        else if( src1.type() == CV_64FC3 && dst.type() == CV_64FC3 )
            func = accProdMask_<Vec3d, Vec3d>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src1, src2, dst, mask );
    }
}


void accumulateWeighted( const Mat& src, Mat& dst, double alpha, const Mat& mask )
{
    CV_Assert( dst.size() == src.size() && dst.channels() == src.channels() );
    
    if( !mask.data )
    {
        AccWFunc func = 0;
        if( src.depth() == CV_8U && dst.depth() == CV_32F )
            func = accW_<uchar, float>;
        else if( src.depth() == CV_8U && dst.depth() == CV_64F )
            func = accW_<uchar, double>;
        else if( src.depth() == CV_32F && dst.depth() == CV_32F )
            func = accW_<float, float>;
        else if( src.depth() == CV_32F && dst.depth() == CV_64F )
            func = accW_<float, double>;
        else if( src.depth() == CV_64F && dst.depth() == CV_64F )
            func = accW_<double, double>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src, dst, alpha );
    }
    else
    {
        CV_Assert( mask.size() == src.size() && mask.type() == CV_8UC1 );

        AccWMaskFunc func = 0;
        if( src.type() == CV_8UC1 && dst.type() == CV_32FC1 )
            func = accWMask_<uchar, float>;
        else if( src.type() == CV_8UC3 && dst.type() == CV_32FC3 )
            func = accWMask_<Vec3b, Vec3f>;
        else if( src.type() == CV_8UC1 && dst.type() == CV_64FC1 )
            func = accWMask_<uchar, double>;
        else if( src.type() == CV_8UC3 && dst.type() == CV_64FC3 )
            func = accWMask_<Vec3b, Vec3d>;
        else if( src.type() == CV_32FC1 && dst.type() == CV_32FC1 )
            func = accWMask_<float, float>;
        else if( src.type() == CV_32FC3 && dst.type() == CV_32FC3 )
            func = accWMask_<Vec3f, Vec3f>;
        else if( src.type() == CV_32FC1 && dst.type() == CV_64FC1 )
            func = accWMask_<float, double>;
        else if( src.type() == CV_32FC3 && dst.type() == CV_64FC3 )
            func = accWMask_<Vec3f, Vec3d>;
        else if( src.type() == CV_64FC1 && dst.type() == CV_64FC1 )
            func = accWMask_<double, double>;
        else if( src.type() == CV_64FC3 && dst.type() == CV_64FC3 )
            func = accWMask_<Vec3d, Vec3d>;
        else
            CV_Error( CV_StsUnsupportedFormat, "" );

        func( src, dst, alpha, mask );
    }
}

}


CV_IMPL void
cvAcc( const void* arr, void* sumarr, const void* maskarr )
{
    cv::Mat src = cv::cvarrToMat(arr), dst = cv::cvarrToMat(sumarr), mask;
    if( maskarr )
        mask = cv::cvarrToMat(maskarr);
    cv::accumulate( src, dst, mask );
}

CV_IMPL void
cvSquareAcc( const void* arr, void* sumarr, const void* maskarr )
{
    cv::Mat src = cv::cvarrToMat(arr), dst = cv::cvarrToMat(sumarr), mask;
    if( maskarr )
        mask = cv::cvarrToMat(maskarr);
    cv::accumulateSquare( src, dst, mask );
}

CV_IMPL void
cvMultiplyAcc( const void* arr1, const void* arr2,
               void* sumarr, const void* maskarr )
{
    cv::Mat src1 = cv::cvarrToMat(arr1), src2 = cv::cvarrToMat(arr2);
    cv::Mat dst = cv::cvarrToMat(sumarr), mask;
    if( maskarr )
        mask = cv::cvarrToMat(maskarr);
    cv::accumulateProduct( src1, src2, dst, mask );
}

CV_IMPL void
cvRunningAvg( const void* arr, void* sumarr, double alpha, const void* maskarr )
{
    cv::Mat src = cv::cvarrToMat(arr), dst = cv::cvarrToMat(sumarr), mask;
    if( maskarr )
        mask = cv::cvarrToMat(maskarr);
    cv::accumulateWeighted( src, dst, alpha, mask );
}

/* End of file. */