FilterWiener

Syntax

Include Files

ippi.h

Domain Dependencies

Headers: ippcore.h, ippvm.h, ipps.h

Libraries: ippcore.lib, ippvm.lib, ipps.lib

Parameters

Description

This function operates with ROI (see Regions of Interest in Intel IPP). This function performs adaptive filtering of the image degraded by constant power additive noise. For each pixel of the input image pSrc, the function estimates the local image mean μ and variance σ in the rectangular neighborhood (mask) of size maskSize with the anchor cell anchor centered on the pixel. The anchor cell is specified by its coordinates anchor.x and anchor.y in the coordinate system associated with the bottom right corner of the mask.

The following formulas are used in computations:

Here μ_i,j and σ_i,j stand for local mean and variance for pixel X_i,j, respectively, and H, W are the vertical and horizontal sizes of the mask, respectively.

The corresponding value for the output pixel Y_i,j is computed as:

and stored in the pDst. Here ν² is the noise variance, specified for each channel by the noise level parameter noise. If this parameter is not defined (noise = 0), then the function estimates the noise level by averaging through the image of all local variances σ_i,j, and stores the corresponding values in the noise for further use.

The function ippiFilterWiener uses the external work buffer pBuffer, which must be allocated before the function call. To determine the required buffer size, the function ippiFilterWienerGetBufferSize can be used.

Figure “Applying the function ippiFilterWiener” illustrates the result of using ippiFilterWiener_32f_C1R function.

Applying the function ippiFilterWiener

Return Values

Example

/*******************************************************************************
* Copyright 2015 Intel Corporation.
*
*
* This software and the related documents are Intel copyrighted materials, and your use of them is governed by
* the express license under which they were provided to you ('License'). Unless the License provides otherwise,
* you may not use, modify, copy, publish, distribute, disclose or transmit this software or the related
* documents without Intel's prior written permission.
* This software and the related documents are provided as is, with no express or implied warranties, other than
* those that are expressly stated in the License.
*******************************************************************************/

//   A simple example of performing two-dimensional adaptive noise-removal filtering of an image using Wiener filter
// implemented with Intel® Integrated Primitives (Intel® IPP) functions:
//     ippiFilterWienerGetBufferSize
//     ippiFilterWiener_32f_C1R


#include <stdio.h>
#include "ipp.h"

#define WIDTH  128  /* image width */
#define HEIGHT  64  /* image height */

/* Next two defines are created to simplify code reading and understanding */
#define EXIT_MAIN exitLine:                                  /* Label for Exit */
#define check_sts(st) if((st) != ippStsNoErr) goto exitLine; /* Go to Exit if Intel® IPP function returned status different from ippStsNoErr */

/* Results of ippMalloc() are not validated because Intel® IPP functions perform bad arguments check and will return an appropriate status  */

int main(void)
{
    IppStatus status = ippStsNoErr;
    Ipp32f* pSrc = NULL, *pDst = NULL;    /* Pointers to source/destination images */
    Ipp32f* pSrcW = NULL;                 /* Pointers to source ROI image */
    int srcStep, dstStep;                 /* Steps, in bytes, through the source/destination images */
    IppiSize roiSize = { WIDTH, HEIGHT }; /* Size of source/destination in pixels */
    IppiSize maskSize = { 3, 3 };
    IppiSize dstRoiSize = {0};            /* Size of destination ROI in pixels */
    IppiPoint anchor = { 1, 1 };          /* Anchor cell specifying the mask alignment\
                                          with respect to the position of the input pixel */
    Ipp32f noise[1] = { 0.0 };            /* Noise level value */
    Ipp8u *pBuffer = NULL;                /* Pointer to the work buffer */
    int iTmpBufSize = 0;                  /* Common work buffer size */
    int numChannels = 1;

    dstRoiSize.width  = WIDTH  - maskSize.width;
    dstRoiSize.height = HEIGHT - maskSize.height;

    /* memory allocation */
    pSrc = ippiMalloc_32f_C1(roiSize.width, roiSize.height, &srcStep);
    pDst = ippiMalloc_32f_C1(roiSize.width, roiSize.height, &dstStep);

    check_sts( status = ippiImageJaehne_32f_C1R(pSrc, srcStep, roiSize) ) /* fill source image */

    check_sts( status = ippiFilterWienerGetBufferSize(dstRoiSize, maskSize, numChannels, &iTmpBufSize) )

    check_sts( status = ippiSet_32f_C1R(1.f, pDst, dstStep, roiSize) )

    pBuffer = ippsMalloc_8u(iTmpBufSize);
    pSrcW = (Ipp32f*)((Ipp8u*)(pSrc + anchor.x) + anchor.y * srcStep);

    check_sts( status = ippiFilterWiener_32f_C1R(pSrcW, srcStep, pDst, dstStep, dstRoiSize, maskSize, anchor, noise, pBuffer) )

EXIT_MAIN
    ippsFree(pBuffer);
    ippiFree(pSrc);
    ippiFree(pDst);
    printf("Exit status %d (%s)\n", (int)status, ippGetStatusString(status));
    return (int)status;
}