Developer Reference

  • 2020
  • 10/21/2020
  • Public Content
Contents

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
IppStatus ippiFilterWiener_<mod>(const Ipp<datatype>*
pSrc
, int
srcStep
, Ipp<datatype>*
pDst
, int
dstStep
, IppiSize
dstRoiSize
, IppiSize
maskSize
, IppiPoint
anchor
, Ipp32f
noise
[3], Ipp8u*
pBuffer
);
Supported values for
mod
:
8u_C3R
16s_C3R
32f_C3R
8u_AC4R
16s_AC4R
32f_AC4R
IppStatus ippiFilterWiener_<mod>(const Ipp<datatype>*
pSrc
, int
srcStep
, Ipp<datatype>*
pDst
, int
dstStep
, IppiSize
dstRoiSize
, IppiSize
maskSize
, IppiPoint
anchor
, Ipp32f
noise
[4], Ipp8u*
pBuffer
);
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
ν
2
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-2020 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 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; }

Product and Performance Information

1

Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserverd for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice.

Notice revision #20110804