image =	separatedBilateral3dImg (inImg,inSpaceSigma,inRangeSigma)
image =	separatedBilateral3dImg (inImg,inHalfKnlSize,inSpaceSigma,inRangeSigma)

Detailed Description

separated version of bilateral filter on 3d image

The separated bilateral filter is an approximation of the Bilateral smoothing 3d that gives resulting images that may be close to what is obtained with the original bilateral filter with dramatically better time performance. The separated bilateral filter is executed in 3 passes: first along x-axis, then along y-axis and finally along z-axis.

Output image pixel values are given by:

$OutImg[x, y, z] = \dfrac { \sum_{o_z=-n}^{n}{W_z(x, y, z, o_z)*OutImg_y[x, y, z+o_z]} } { \sum_{o_z=-n}^{n}{W_z(x, y, z, o_z)} }$

where:

$OutImg_y[x, y, z] = \dfrac { \sum_{o_y=-n}^{n}{W_y(x, y, z, o_y)*OutImg_x[x, y+o_y, z]} } { \sum_{o_y=-n}^{n}{W_y(x, y, z, o_y)} }$
$OutImg_z[x, y, z] = \dfrac { \sum_{o_x=-n}^{n}{W_x(x, y, z, o_x)*InImg[x+o_x, y, z]} } { \sum_{o_x=-n}^{n}{W_x(x, y, z, o_x)} }$
is the weight function along x-axis; $W_x(x, y, z, o_x)=f_S(o_x, 0, 0)*f_{Rx}(InImg, x, y, z, o_x)$
is the weight function along y-axis; $W_y(x, y, z, o_y)=f_S(0, o_y, 0)*f_{Ry}(InImg, x, y, z, o_y)$
is the weight function along z-axis; $W_z(x, y, z, o_z)=f_S(0, 0, o_z)*f_{Rz}(InImg, x, y, z, o_z)$
is the space function; $f_S(o_x, o_y, o_z)=e^{-\dfrac{o_x^2+o_y^2+o_z^2}{2*\sigma_S^2}}$
$f_{Rx}(InImg, x, y, z, o_x)= \begin{cases} 1, & \text{if } o_x=0 \\ f_R(|InImg[x, y, z]-InImg[x+o_x, y, z]|), & \text{if } o_x > 0 \text { and } f_R(|InImg[x, y, z]-InImg[x+o_x, y, z]|) < f_{Rx}(x, y, z, o_x-1) \\ f_{Rx}(x, y, z, o_x-1), & \text{if } o_x > 0 \text { and } f_R(|InImg[x, y, z]-InImg[x+o_x, y, z]|) \geq f_{Rx}(x, y, z, o_x-1) \\ f_R(|InImg[x, y, z]-InImg[x+o_x, y, z]|), & \text{if } o_x < 0 \text { and } f_R(|InImg[x, y, z]-InImg[x+o_x, y, z]|) < f_{Rx}(x, y, z, o_x+1) \\ f_{Rx}(x, y, z, o_x+1), & \text{if } o_x < 0 \text { and } f_R(|InImg[x, y, z]-InImg[x+o_x, y, z]|) \geq f_{Rx}(x, y, z, o_x+1) \end{cases}$
$f_{Ry}(InImg, x, y, z, o_y)= \begin{cases} 1, & \text{if } o_y=0 \\ f_R(|InImg[x, y, z]-InImg[x, y+o_y, z]|), & \text{if } o_y > 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y+o_y, z]|) < f_{Ry}(x, y, z, o_y-1) \\ f_{Ry}(x, y, z, o_y-1), & \text{if } o_y > 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y+o_y, z]|) \geq f_{Ry}(x, y, z, o_y-1) \\ f_R(|InImg[x, y, z]-InImg[x, y+o_y, z]|), & \text{if } o_y < 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y+o_y, z]|) < f_{Ry}(x, y, z, o_y+1) \\ f_{Ry}(x, y, z, o_y+1), & \text{if } o_y < 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y+o_y, z]|) \geq f_{Ry}(x, y, z, o_y+1) \end{cases}$
$f_{Rz}(InImg, x, y, z, o_z)= \begin{cases} 1, & \text{if } o_z=0 \\ f_R(|InImg[x, y, z]-InImg[x, y, z+o_z]|), & \text{if } o_z > 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y, z+o_z]|) < f_{Rz}(x, y, z, o_z-1) \\ f_{Rz}(x, y, z, o_z-1), & \text{if } o_z > 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y, z+o_z]|) \geq f_{Rz}(x, y, z, o_z-1) \\ f_R(|InImg[x, y, z]-InImg[x, y, z+o_z]|), & \text{if } o_z < 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y, z+o_z]|) < f_{Rz}(x, y, z, o_z+1) \\ f_{Rz}(x, y, z, o_z+1), & \text{if } o_z < 0 \text { and } f_R(|InImg[x, y, z]-InImg[x, y, z+o_z]|) \geq f_{Rz}(x, y, z, o_z+1) \end{cases}$
is the range function; $f_R(r)=e^{-\dfrac{r^2}{2*\sigma_R^2}}$
is defined by InOptHalfKnlSize attribute (if this attribute is not initialized, then equals to $1.5*\sigma_S$ )
$\sigma_R$ is defined by InRangeSigma attribute
$\sigma_S$ is defined by InSpaceSigma attribute

Input and output images must have same size.

See Separated bilateral smoothing 2d for an illustration of separated bilateral filter applied to a 2d image.

See also: M. Moreaud, F. Cokelaer, Flowing Bilateral Filter : definition and GPU implementation, Image Analysis and Stereology (revision in progress)

Example of Python code :

Example imports

import PyIPSDK

import PyIPSDK.IPSDKIPLFiltering as filter

Code Example

    # opening of input images
    inImg = PyIPSDK.loadTiffImageFile(inputImgPath)
    
    # separable bilateral filter 3d computation
    outImg = filter.separatedBilateral3dImg(inImg, 5, 3)

Example of C++ code :

Example informations

Header file

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

Code Example

        // opening input image
        ImagePtr pInImg = loadTiffImageFile(inputImgPath);
        // definition of a custom output geometry
        ImageGeometryPtr pOutImageGeometry = geometry3d(
            outImageBufferType,
            pInImg->getSizeX(),
            pInImg->getSizeY(),
            pInImg->getSizeZ());
        // creation of output image
        boost::shared_ptr<MemoryImage> pOutImg = boost::make_shared<MemoryImage>();
        pOutImg->init(*pOutImageGeometry);
        // compute bilateral filter on input image
        separatedBilateral3dImg(pInImg, inHalfKnlSize, inSpaceSigma, inRangeSigma, pOutImg);