Smoothing Floatingpoint Mat, with a mask

edit

I have not used the OpenCV to implement it.I've already implemented this code in ANSI C language. This code simply by changing the name of its functions is to become the Opencv C Edition.Stationary Gaussian kernel is used in the regular version but in the gaussian filter with mask for each pixel non zero in the mask you have to compute gaussian kernel for it.

typedef struct BhImageA
{
    int width;       //Image width in pixels
    int height;      // Image height in pixels
    int widthStep;   // The size of an aligned image row, in bytes
    byte* imageData; //A pointer to the aligned image data
    byte depth;      //Channel depth in bits
    BhRectA roi;     // Region Of Interest (ROI). If not NULL, only this image region will be processed
}BhImageA;

typedef struct BhRectA
{
    int x;  // Offset (usually the top-left corner) and size of a rectangle
    int y;  // y-coordinate of the top-left corner
    int width;  // y-coordinate of the top-left corner
    int height;  // y-coordinate of the top-left corner
}BhRectA;

#define BH_DEPTH_8  8
#define BH_DEPTH_32 32
#define BH_DEPTH_32_F 64
BhSizeA bhSizeA(int width,int height)
{
    BhSizeA result;
    result.width = width;
    result.height = height;
    return result;
}

BhRectA bhGetImageRectA(BhImageA* srcImage)
{
    BhRectA result;
    result.x = 0;
    result.y = 0;
    result.width = srcImage->width;
    result.height = srcImage->height;
    return result;
}
int bhGetWidthStepA(int width)
{
    return  int(ceil(width / 4.0)*4);
}
void bhMulSA(BhImageA* srcImage,BhImageA* dstImage,double value)
{
    if (srcImage->depth == BH_DEPTH_8)
    {
        byte v=(byte)value;
        for (int i = 0; i < srcImage->height; i++)
        {
            byte* srcRow = srcImage->imageData + srcImage->widthStep * i;
            byte* dstRow = dstImage->imageData + dstImage->widthStep * i;
            for (int j = 0; j < srcImage->width; j++)
                dstRow[j] = srcRow[j]* v;

        }
    }
    else if (srcImage->depth == BH_DEPTH_32)
    {
        int v=(int)value;
        for (int i = 0; i < srcImage->height; i++)
        {
            int* srcRow = (int*)srcImage->imageData + srcImage->widthStep * i;
            int* dstRow = (int*)dstImage->imageData + dstImage->widthStep * i;
            for (int j = 0; j < srcImage->width; j++)
                dstRow[j] = srcRow[j]* v;


        }

    }
    else if (srcImage->depth == BH_DEPTH_32_F)
    {
        float v=(double)value;
        for (int i = 0; i < srcImage->height; i++)
        {
            float* srcRow = (float*)srcImage->imageData + srcImage->widthStep * i;
            float* dstRow = (float*)dstImage->imageData + dstImage->widthStep * i;
            for (int j = 0; j < srcImage->width; j++)
                dstRow[j] = srcRow[j]* v;

        }
    }
}

double bhSumA(BhImageA* srcImage,BhImageA* maskImage)
{
    double sum = 0;
    BhRectA roi = srcImage->roi;
    if (maskImage == NULL)
    {
        if (srcImage->depth == BH_DEPTH_8)
        {
            for (int i = roi.y; i < roi.y + roi.height; i++)
            {
                byte* row = srcImage->imageData + srcImage->widthStep * i;
                for (int j = roi.x; j < roi.x + roi.width; j++)
                    sum += row[j];

            }
        }
        else if (srcImage->depth == BH_DEPTH_32)
        {
            for (int i = roi.y; i < roi.y + roi.height ; i++)
            {
                int* row = (int*)srcImage->imageData + srcImage->widthStep * i;
                for (int j = roi.x ; j < roi.x + roi.width; j++)
                    sum += row[j];

            }

        }
        else if (srcImage->depth == BH_DEPTH_32_F)
        {
            for (int i = roi.y; i < roi.y + roi.height ; i++)
            {
                float* row = (float*)srcImage->imageData + srcImage->widthStep * i;
                for (int j = roi.x; j < roi.x + roi.width; j++)
                    sum += row[j];

            }

        }
    }
    else if (maskImage != NULL)
    {
        if (srcImage->width != maskImage- ...