outImg,outParams =	patchBasedBilateral2dImg (inImg)
PatchBasedBilateralParams =	patchBasedBilateral2dImg (inImg,outImg)
outImg,outParams =	patchBasedBilateral2dImg (inImg,params)
PatchBasedBilateralParams =	patchBasedBilateral2dImg (inImg,params,outImg)

Detailed Description

Patch-based bilateral filter on 2d image.

Patch-based bilateral filter is an algorithm used for image denoising. Like the Bilateral smoothing 2d, each pixel value is replaced by a weighted average of the values of its neighbours, and the weight is a product of two gaussian functions, one depending on the spatial distance between the 2 pixels, and the other one depending on intensity similarities. But contrary to the original version of the bilateral filter, the intensity similarity is not computed between 2 pixels, but between their 2 square neighbourhoods.

In term of results, this algorithm outperforms the original bilateral filter(better preservation of details and structures in the image) and gives results similar to the non-local means filter when one of the parameters, the spatial sigma, is great enough.

On output image values are given by:

$OutImg[x, y] = \dfrac { \sum_{(o_x, o_y) \in K}{W(x, y, o_x, o_y)*InImg[x+o_x, y+o_y]} } { \sum_{(o_x, o_y) \in K}{W(x, y, o_x, o_y)} }$

where:

is the weight function; $W(x, y, o_x, o_y)=f_{Space}(o_x, o_y)*f_{Similarity}(x, y, o_x, o_y)$
$f_{Space}$ is the space function; $f_{Space}(o_x, o_y)=e^{-\dfrac{o_x^2+o_y^2}{2*\sigma_{Space}^2}}$
$f_{Similarity}$ is the intensity similarity function; $f_Similarity(r)=e^{-\dfrac{|P(x, y), P(x+o_x, y+o_y)|^2-2*\sigma_{Noise}^2}{2*\sigma_{Similarity}^2}}$
P is the square patch centered on pixel (x, y), of a given half-size, specified by the user through the parameter field PatchBasedBilateralParams::PatchHalfSize
|.| is a L2 distance operator, used to compute an intensity distance between 2 patches
is a disk-shaped kernel of a given radius, specified by the user through the parameter field PatchBasedBilateralParams::KernelRadius
$\sigma_{Similarity}$ is defined by PatchBasedBilateralParams::PatchSimilaritySigma parameter field
$\sigma_{Space}$ is defined by PatchBasedBilateralParams::SpaceSigma parameter field
$\sigma_{Noise}$ stands for the standard deviation of the gaussian noise in the image and is defined by PatchBasedBilateralParams::NoiseSigma parameter field

Input and output images must have same size.

Note: On a color image, the filter is applied independently to each channel of the image. There is no dedicated version of the filter for color images for the moment.

Adjusting the parameters of the filter requires some expertise. To simplify the user's task, it is possible to execute the filter in semi-automatic or in full-automatic mode:

in full-automatic mode, the user doesn't need to initialize the PatchBasedBilateralParams parameters of the algorithm; then the filter computes internally the standard deviation of the gaussian noise in the input image, and automatically computes the parameters of the algoritm from this level of noise. To use this full-automatic mode, call the wrapper function patchBasedBilateral2dImg, that takes only input and output images as arguments, and that returns the automatically computed parameters.
in semi-automatic mode, the user only needs to initialize the parameters by using the function createPatchBasedBilateralParams that takes a noise standard deviation as single argument, before passing them as input of the filter; then parameters are automatically computed from this noise standard deviation. This mode may be a good alternative to the full-automatic one, if the user is not satisfied by the result returned by this last one, but wants to adjust the behaviour of the filter by modifying only one parameter.

These 2 modes usually give satisfying results, provided the noise of the input image follows a gaussian distribution. If this is not the case, using one of the 2 automatic modes may be a good starting point, but it will be certainly necessary to adjust manually the parameters afterward.

Here is an example of a patch-based bilateral filter (parameters were automatically computed by the filter itself, and equal to: $patchHalfSize=1$ , $kernelRadius=3$ , $patchSimilaritySigma=5.76$ and $spatialSigma=3.0$ ) applied to an 8-bits grey levels input image with an artificially added gaussian noise ( $\sigma=5.0$ ):

Example of Python code :

Example imports

import PyIPSDK
import PyIPSDK.IPSDKIPLFiltering as filter
import PyIPSDK.IPSDKIPLUtility as util

Code Example

    # opening of input images
    inImg = PyIPSDK.loadTiffImageFile(inputImgPath)
    inImg = util.convertImg(inImg,  PyIPSDK.eImageBufferType.eIBT_Real32)
    
    # patch-based bilateral filter 2d computation
    outImg, autoParams = filter.patchBasedBilateral2dImg(inImg)

Example of C++ code :

Example informations

Header file

#include <IPSDKIPL/IPSDKIPLFiltering/Processor/PatchBasedBilateral2dImg/PatchBasedBilateral2dImg.h>

Code Example

        // definition of a custom output geometry
        ImageGeometryPtr pOutImageGeometry =
            geometry2d(outImgBufferType,
                       pInImg->getSizeX(),
                       pInImg->getSizeY());
        // creation of output image
        boost::shared_ptr<MemoryImage> pOutImg = boost::make_shared<MemoryImage>();
        pOutImg->init(*pOutImageGeometry);
        // compute patch-based bilateral filter on input image
        PatchBasedBilateralParamsPtr pOutParams = patchBasedBilateral2dImg(
            pInImg,
            createPatchBasedBilateralParams(inPatchHalfSize, inKernelRadius, inPatchSimilaritySigma, inSpaceSigma, inNoiseSigma),
            pOutImg);