FilterWiener

Intel® Integrated Performance Primitives (Intel® IPP) Developer Guide and Reference

Download PDF

ID 790148

Date 3/22/2024

Version

Public

Visible to Intel only — GUID: GUID-C2662978-6D97-48BF-903B-52523CAD0DFC

View Details

FilterWiener

Filters an image using the Wiener algorithm.

Syntax

Case 1: Operation on one-channel images

IppStatus ippiFilterWiener_<mod>(const Ipp<datatype>* pSrc, int srcStep, Ipp<datatype>* pDst, int dstStep, IppiSize dstRoiSize, IppiSize maskSize, IppiPoint anchor, Ipp32f noise[1], Ipp8u* pBuffer);

Supported values for mod:

8u_C1R

16s_C1R

32f_C1R

Case 2: Operation on multi-channel images

Supported values for mod:

8u_C3R	16s_C3R	32f_C3R
8u_AC4R	16s_AC4R	32f_AC4R

Supported values for mod:

8u_C4R

16s_C4R

32f_C4R

Include Files

ippi.h

Domain Dependencies

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

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

Parameters

pSrc	Pointer to the source image ROI.
srcStep	Distance in bytes between starts of consecutive lines in the source image.
pDst	Pointer to the destination image ROI.
dstStep	Distance in bytes between starts of consecutive lines in the destination image.
dstRoiSize	Size of the source and destination ROI in pixels.
maskSize	Size of the mask in pixels.
anchor	Anchor cell specifying the mask alignment with respect to the position of the input pixel.
noise	Noise level value or array of the noise level values in case of multi-channel image. This value must be in the range [0,1].
pBuffer	Pointer to the external work buffer.

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

ippStsNoErr	Indicates no error. Any other value indicates an error.
ippStsNullPtrErr	Indicates an error condition if one of the specified pointers is NULL.
ippStsSizeErr	Indicates an error condition if one of the fields of dstRoiSize has a zero or negative value.
ippStsMaskSizeErr	Indicates an error condition if one of the fields of maskSize has a value less than or equal to 1.
ippStsNoiseRangeErr	Indicates an error condition if one of the noise values is less than 0 or greater than 1.

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(R) Integrated Performance Primitives (Intel(R) 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(R) IPP function returned status different from ippStsNoErr */

/* Results of ippMalloc() are not validated because Intel(R) 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;
}

Parent topic: Wiener Filters

Select Your Language

Using Intel.com Search

Quick Links

Recent Searches

Advanced Search

Only search in

Intel® Integrated Performance Primitives (Intel® IPP) Developer Guide and Reference

FilterWiener

Syntax

Include Files

Domain Dependencies

Parameters

Description

Return Values

Example