Classes | Functions
Image preprocessing filters

Classes

struct  i3d::Filter< NUMBER >
 General filter structure. More...
struct  i3d::Separable3dFilter< VOXEL >
 Structure for representing separable filter of arbitrary sizes in each directions/axis. More...
struct  i3d::BorderPadding< VOXEL >
 Structure containing data that is used for input image expansion. More...
class  i3d::GradientMagnitudeEstimator< VOXEL >
 This class implements simple Estimator of the gradient magnitude. More...
class  i3d::SpatialDerivatives< VOXEL >
 This class implements spatial derivatives operator neede for optical flow comp. More...
class  i3d::AOSCLMCFilter< VOXELIN, VOXELOUT >
 This class implements the nonlinear diffusion filter, which was published by Catte, Lions, Morel and Coll. More...
class  i3d::AOSTVFilter< VOXELIN, VOXELOUT >
 This class implements the Total Variations nonlinear diffusion filter and the Ballanced Forward Backward filter, which were published by Andreu et al. More...
class  i3d::AOSPMFilter< VOXELIN, VOXELOUT >
 This class implements the Perona-Malik anisotropic diffusion filter, which was published by Perona and Malik. More...
class  i3d::LODGaussianBlur< VOXELIN, VOXELOUT >
 This class implements the classical Gaussian Blur filter by solving the following PDE $ u_t = \Delta u = (u_{xx} + u_{yy}) $. More...
class  i3d::MCFFilter< VOXELIN, VOXELOUT >
 This class implements together with class MCFFilterFunction the Curvature Flow anisotropic diffusion filter, which was published by Alvarez, Lions and Morel. More...
class  i3d::PMFilter< VOXELIN, VOXELOUT >
 This class implements together with class PMFilterFunction the Perona-Malik anisotropic diffusion filter, which was published by Perona and Malik. More...
class  i3d::MCDEFilter< VOXELIN, VOXELOUT >
 This class implements together with class MCDEFilterFunction the Modified Curvature Diffusion Flow anisotropic diffusion filter, which was published by Whitaker and Xue. More...

Functions

template<class PRECISION , class T_in , class T_out >
void i3d::Convolution (const Image3d< T_in > &img_in, const Image3d< T_in > &kernel, Image3d< T_out > &img_out, bool normalize_kernel=true, BoundaryConditionType boundary_condition=BoundaryDirichlet)
template<class NUMBER , class NUMBER2 >
void i3d::Convert (Filter< NUMBER > &out, const Filter< NUMBER2 > &in)
template<class NUMBER >
void i3d::Convert (Filter< NUMBER > &out, const Filter< NUMBER > &in)
template<class T >
void i3d::SuppresHotPixels (const Image3d< T > &in, Image3d< T > &out, const Neighbourhood &neib, T thres)
template<class VOXEL >
int i3d::NaiveConvolution (Image3d< VOXEL > const &in,Image3d< VOXEL > const &kern,Image3d< VOXEL > &out,const VOXEL border=0)
template<typename T >
I3D_ALGO_EXPORT void i3d::MedianFilter (const Image3d< T > &img_in, Image3d< T > &img_out, const Neighbourhood &neib)
template<typename T >
void i3d::rankFilterByHistogram (const i3d::Image3d< T > &imgIn, i3d::Image3d< T > &imgOut, Neighbourhood &SEin, int rank)

Gauss filtering

Filter< double > i3d::MakeGaussFilter1D (double sigma, double widthFactor=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::ApplyGauss1D (VOXEL *data, const std::slice &slc, Filter< double > &filter, Buffer &buf, bool divide=true)
template<class VOXEL >
void i3d::Gauss (Image3d< VOXEL > &, double sigmax, double sigmay=0.0, double sigmaz=0.0, double widthFactor=3.0, bool exact=true)
template<class VOXEL >
void i3d::SimpleGauss (Image3d< VOXEL > &img, double sigma=STD_SIGMA, bool exact=true)
template<class VOXEL >
void i3d::EstimateGaussKernel (struct Separable3dFilter< VOXEL > &filter, const VOXEL sigmaX, const VOXEL sigmaY, const VOXEL sigmaZ, const float widthX=3.0, const float widthY=3.0, const float widthZ=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR (Image3d< VOXEL > const &In, Image3d< VOXEL > &Out, const VOXEL Sigma, const float Width=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR (Image3d< VOXEL > &img, const VOXEL Sigma, const float Width=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR (Image3d< VOXEL > const &In, Image3d< VOXEL > &Out, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ, const float WidthX=3.0, const float WidthY=3.0, const float WidthZ=3.0)
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR (Image3d< VOXEL > &img, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ, const float WidthX=3.0, const float WidthY=3.0, const float WidthZ=3.0)
template<class VOXEL >
void i3d::GaussIIR (Image3d< VOXEL > &img, const VOXEL Sigma)
template<class VOXEL >
void i3d::GaussIIR (Image3d< VOXEL > &img, const VOXEL SigmaX, const VOXEL SigmaY, const VOXEL SigmaZ)
template<class VOXEL , class PRECISION >
void i3d::GrayGaussIIR (Image3d< VOXEL > &img, const PRECISION Sigma)
template<class VOXEL , class PRECISION >
void i3d::GrayGaussIIR (Image3d< VOXEL > &img, const PRECISION SigmaX, const PRECISION SigmaY, const PRECISION SigmaZ)
#define STD_SIGMA   0.84932180028801904272
struct I3D_ALGO_EXPORT i3d::Separable3dFilter

Separable convolution

template<class VOXEL >
void i3d::PrepareZeroBoundaryForFilter (struct Separable3dFilter< VOXEL > const &filter, BorderPadding< VOXEL > &b)
template<class VOXEL >
I3D_ALGO_EXPORT int i3d::SeparableConvolution (Image3d< VOXEL > const &d, Image3d< VOXEL > &res, struct Separable3dFilter< VOXEL > const &f, struct BorderPadding< VOXEL > const &b)

Define Documentation

#define STD_SIGMA   0.84932180028801904272

STD_SIGMA == 1/sqrt(ln(4))


Function Documentation

template<class PRECISION , class T_in , class T_out >
I3D_ALGO_EXPORT void i3d::Convolution ( const Image3d< T_in > &  img_in,
const Image3d< T_in > &  kernel,
Image3d< T_out > &  img_out,
bool  normalize_kernel = true,
BoundaryConditionType  boundary_condition = BoundaryDirichlet 
)

Convolution implemented via Fast Fourier transform.

This function implements the Fourier transform based convolution. The main idea originates from convolution theorem which says that convolution in image domain corresponds to point-wise multiplication in Fourier domain. The Fourier domain is realized via FFTW package (www.fftw.org).

Moreover, if the image and kernel are too huge to be processed in the computer memory, the image and kernel are tiled into smaller pieces and the convolution is performed over these small portions. Finally, the portions are sewed together.

The size of the portions is set to be optimal with respect to FFTW.

Parameters:
[in]img_ininput image
[in]kernelconvolution kernel (image)
[out]img_outoutput (convolved) image, needn't be allocated
[in]normalize_kernel... query whether the kernel is to be normalized (optional parameter)
Author:
David Svoboda <svoboda@fi.muni.cz>
Date:
October 2009
template<class NUMBER , class NUMBER2 >
void i3d::Convert ( Filter< NUMBER > &  out,
const Filter< NUMBER2 > &  in 
)

Filter conversion (to another arithmetic type):

template<class NUMBER >
void i3d::Convert ( Filter< NUMBER > &  out,
const Filter< NUMBER > &  in 
)

"Conversion" to the same filter type - just a deep copy:

Filter< double > i3d::MakeGaussFilter1D ( double  sigma,
double  widthFactor = 3.0 
)

MakeGaussFilter1D computes a window for a 1D Gaussian filter given by the standard deviation (sigma) and a factor influencing the size of the window (widthFactor).

The size of the window is 2*[sigma*widthFactor], where [x] means the lowest integer larger than x. The filter is multiplied by a constant to get 1 on both ends of the window. The value of sigma must be in the range [0.01, 32], otherwise InternalException is thrown.

template<class VOXEL >
I3D_ALGO_EXPORT void i3d::ApplyGauss1D ( VOXEL *  data,
const std::slice &  slc,
Filter< double > &  filter,
Buffer &  buf,
bool  divide = true 
)

Apply a 1D Gaussian filter a vector selected from data using slc.

The filter is given as one of the parameters, as well as a buffer, which has to be of the same size as the filter window ( = filter.Size() * sizeof(VOXEL) ). If the optional parameter divide is false, then the result of the scalar product with the filter window is not divided by the sum of the window, which means that the function computes just a convolution with the filter window. The range of each result is checked and an exception is raised if it exceeds numeric_limits<VOXEL>::max().

template<class VOXEL >
void i3d::Gauss ( Image3d< VOXEL > &  img,
double  sigmax,
double  sigmay = 0.0,
double  sigmaz = 0.0,
double  widthFactor = 3.0,
bool  exact = true 
)

Gauss applies a 1-3D Gaussian filter to an image.

If some of sigmax, sigmay, or sigmaz are zero, then the image is not filtered in the corresponding axis. For instance, the image is filtered only in the z axis by calling Gauss(image, 0, 0, sigma).

widthFactor influences the size of the filter window: the Gauss filter is implemented by consecutive application of a 1D Gauss filter with window size of 2*[sigma*widthFactor], where [x] means the lowest integer larger than x.

2D and 3D filters are computed by a consecutive application of two or three 1D Gaussian filters produced by MakeGaussFilter1D. The widthFactor parameter has the same meaning as in MakeGaussFilter1D.

If the optional parameter exact is false, the computation is done in situ, however some rounding errors can occur. Otherwise, a temporary buffer is allocated for storing the intermediate results. The size of the buffer can be up to four times of the size of the image, depending on the voxel type.

template<class VOXEL >
void i3d::SimpleGauss ( Image3d< VOXEL > &  img,
double  sigma = STD_SIGMA,
bool  exact = true 
)

SimpleGauss: applies a simple Gauss filter (1,x,1), where x increases with decreasing sigma, in all available dimensions of the image.

The function supposes that if the image has z-dimension then is has also y-dimension and if it has y-dimension then is has also x-dimension. With sigma == STD_SIGMA we get filter window (1,2,1)*1/4. The parameter exact has the same meaning as in the Gauss() function.

template<class VOXEL >
void i3d::EstimateGaussKernel ( struct Separable3dFilter< VOXEL > &  filter,
const VOXEL  sigmaX,
const VOXEL  sigmaY,
const VOXEL  sigmaZ,
const float  widthX = 3.0,
const float  widthY = 3.0,
const float  widthZ = 3.0 
)

Changes the separable filter so that it be Gaussian-shaped.

The content of input filter is removed first in all directions (along all three axes). Directions along axes are then filled with coefficients of Gaussian filters using respective sigmas. Also, the span of the filter along each direction is proportional to the value of the respective sigma and width. Axes are selected according to the values of respective sigmas. Non-zero value indicates the presence of given axis in the created filter. Default width values are 3.0.

Parameters:
[in,out]filterreference to the filter structure to be filled in
[in]sigmaXsigma of the Gauss filter's part along x-axis
[in]sigmaYsigma of the Gauss filter's part along y-axis
[in]sigmaZsigma of the Gauss filter's part along z-axis
[in]widthXwidth of the filter along x-axis which would be roundup(sigma*width)*2+1 in reality
[in]widthYwidth of the filter along x-axis which would be roundup(sigma*width)*2+1 in reality
[in]widthZwidth of the filter along x-axis which would be roundup(sigma*width)*2+1 in reality
Author:
Vladimír Ulman
Date:
2007
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR ( Image3d< VOXEL > const &  In,
Image3d< VOXEL > &  Out,
const VOXEL  Sigma,
const float  Width = 3.0 
)

Apply gaussian blur on image.

This is a convolution with classical FIR (Finite Impulse Response) filter. Border is extended by zeros.

The Sigma is the same for all involved directions of Gaussian. Also, the span of the filter along each direction is proportional to the value of the same single Sigma and Width. The selection of axes involved in the filtering depends on the respective dimensions of input image. Default Width value is 3.0.

Note:
Attention: In and Out images must be different! If both references point to the same image (memory) the result of filtering is not valid!
Parameters:
[in]Ininput Image3d<>
[out]Outoutput (Gaussian blurred) Image3d<>
[in]SigmaSigma of the Gauss filter
[in]WidthWidth of the Gauss filter
Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2007
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR ( Image3d< VOXEL > &  img,
const VOXEL  Sigma,
const float  Width = 3.0 
)

Apply gaussian blur on image.

This is a convolution with classical FIR (Finite Impulse Response) filter. Border is extended by zeros.

The Sigma is the same for all involved directions of Gaussian. Also, the span of the filter along each direction is proportional to the value of the same single Sigma and Width. The selection of axes involved in the filtering depends on the respective dimensions of input image. Default Width value is 3.0.

Note:
Be aware of the fact that this is just a wrapper to the GaussFIR(InImage,OutImage,...) function. The image img is first copied aside what introduces some latency.
Parameters:
[in,out]imginput and output (Gaussian blurred) Image3d<>
[in]SigmaSigma of the Gauss filter
[in]WidthWidth of the Gauss filter
Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2007
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR ( Image3d< VOXEL > const &  In,
Image3d< VOXEL > &  Out,
const VOXEL  SigmaX,
const VOXEL  SigmaY,
const VOXEL  SigmaZ,
const float  WidthX = 3.0,
const float  WidthY = 3.0,
const float  WidthZ = 3.0 
)

Apply gaussian blur on image.

This is a convolution with classical FIR (Finite Impulse Response) filter. Border is extended by zeros.

The function uses different Sigma for filtering of each axis. Also, the span of the filter along each direction is proportional to the value of the respective Sigma and Width. Axes are selected according to the values of respective sigmas and according to the size of input image along direction in question. Non-zero value of given Sigma indicates the wish to filter along respective axis. Default Width values are 3.0.

Note:
Attention: In and Out images must be different! If both references point to the same image (memory) the result of filtering is not valid!
Parameters:
[in]Ininput Image3d<>
[out]Outoutput (Gaussian blurred) Image3d<>
[in]SigmaXSigma of the Gauss filter along x-axis
[in]SigmaYSigma of the Gauss filter along y-axis
[in]SigmaZSigma of the Gauss filter along z-axis
[in]WidthXWidth of the Gauss filter along x-axis
[in]WidthYWidth of the Gauss filter along y-axis
[in]WidthZWidth of the Gauss filter along z-axis
Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2007
template<class VOXEL >
I3D_ALGO_EXPORT void i3d::GaussFIR ( Image3d< VOXEL > &  img,
const VOXEL  SigmaX,
const VOXEL  SigmaY,
const VOXEL  SigmaZ,
const float  WidthX = 3.0,
const float  WidthY = 3.0,
const float  WidthZ = 3.0 
)

Apply gaussian blur on image.

This is a convolution with classical FIR (Finite Impulse Response) filter. Border is extended by zeros.

The function uses different Sigma for filtering of each axis. Also, the span of the filter along each direction is proportional to the value of the respective Sigma and Width. Axes are selected according to the values of respective sigmas and according to the size of input image along direction in question. Non-zero value of given Sigma indicates the wish to filter along respective axis. Default Width values are 3.0.

Note:
Be aware of the fact that this is just a wrapper to the GaussFIR(InImage,OutImage,...) function. The image img is first copied aside what introduces some latency.
Parameters:
[in,out]imginput and output (Gaussian blurred) Image3d<>
[in]SigmaXSigma of the Gauss filter along x-axis
[in]SigmaYSigma of the Gauss filter along y-axis
[in]SigmaZSigma of the Gauss filter along z-axis
[in]WidthXWidth of the Gauss filter along x-axis
[in]WidthYWidth of the Gauss filter along y-axis
[in]WidthZWidth of the Gauss filter along z-axis
Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2007
template<class VOXEL >
void i3d::GaussIIR ( Image3d< VOXEL > &  img,
const VOXEL  Sigma 
)

Apply gaussian blur on image when the Gauss filter is aproximated by IIR filter.

This is a recursive convolution with IIR (Infinite Impulse Response) filter. The filter is estimated according to [Vliet, Young and Ginkel, 2002]. The borders are treated by extending the boundary value as neccessary, according to [Triggs and Sdika, 2006].

The Sigma is the same for all involved directions of Gaussian. The selection of axes involved in the filtering depends on the respective dimensions of input image.

Sigma shouldn't be smaller than 1.0.

Parameters:
[in,out]imginput and output (Gaussian blurred) Image3d<>
[in]SigmaSigma of the Gauss filter

Literature: I. T. Young, L. J. van Vliet and M. van Ginkel. Recursive Gabor filtering. In Signal processing 50, 11. Pages 2798-2805. 2002.

Literature: B. Triggs and M. Sdika. Boundary conditions for Young-van Vliet recursive filtering. In Signal processing 54, 5. 2006.

Note:
This is a prefered IIR implementation. It is faster then FIR Gauss. The difference becomes even more substantional as Sigma increases roughly over 3.

The function is instantiated only for voxel types float and double.

Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2007
template<class VOXEL >
void i3d::GaussIIR ( Image3d< VOXEL > &  img,
const VOXEL  SigmaX,
const VOXEL  SigmaY,
const VOXEL  SigmaZ 
)

Apply gaussian blur on image when the Gauss filter is aproximated by IIR filter.

This is a recursive convolution with IIR (Infinite Impulse Response) filter. The filter is estimated according to [Vliet, Young and Ginkel, 2002]. The borders are treated by extending the boundary value as neccessary, according to [Triggs and Sdika, 2006].

The function uses different Sigma for filtering of each axis. Axes are selected according to the values of respective sigmas and according to the size of input image along direction in question. Non-zero value of given Sigma indicates the wish to filter along respective axis.

Sigma shouldn't be smaller than 1.0. Or should be exactly zero to show along which axis filtering shouldn't take place.

Parameters:
[in,out]imginput and output (Gaussian blurred) Image3d<>
[in]SigmaXSigma of the Gauss filter along x-axis
[in]SigmaYSigma of the Gauss filter along y-axis
[in]SigmaZSigma of the Gauss filter along z-axis

Literature: I. T. Young, L. J. van Vliet and M. van Ginkel. Recursive Gabor filtering. In Signal processing 50, 11. Pages 2798-2805. 2002.

Literature: B. Triggs and M. Sdika. Boundary conditions for Young-van Vliet recursive filtering. In Signal processing 54, 5. 2006.

Note:
This is a prefered IIR implementation. It is faster then FIR Gauss. The difference becomes even more substantional as Sigma increases roughly over 3.

The function is instantiated only for voxel types float and double.

Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2007
template<class T >
void i3d::SuppresHotPixels ( const Image3d< T > &  in,
Image3d< T > &  out,
const Neighbourhood &  neib,
thres 
)

Suppress pixels differing too much from its neigbours let avg(i) be the avarage intensity of the neigbours of pixel i in the image in then this rule is applied in each pixel: out(i) = in(i) if (abs(avg(i)-in(i)) < thres ) out(i) = avg(i) otherwise.

template<class VOXEL >
void i3d::PrepareZeroBoundaryForFilter ( struct Separable3dFilter< VOXEL > const &  filter,
BorderPadding< VOXEL > &  b 
)

Changes the BorderPadding structure to describe zero image boundary extension.

The content of the input border paddings structure is removed in all directions (along all three axes) first. Some axes, according to the directions set in the convolution filter, are then filled with zeros so that it describes zero extension. The widths of the extensions (3 possible extensions due to 3 possible axes) is deduced from the filter spans.

For example see the code of GaussFIR() in filters.cc.

Parameters:
[in]filterreference to a filter to be filtered with
[in,out]breference to the paddings structure
Author:
Vladimír Ulman
Date:
2007
template<class VOXEL >
I3D_ALGO_EXPORT int i3d::SeparableConvolution ( Image3d< VOXEL > const &  d,
Image3d< VOXEL > &  res,
struct Separable3dFilter< VOXEL > const &  f,
struct BorderPadding< VOXEL > const &  b 
)

Convolution of input image extended by given user data.

  1. Input image: d (a regular float or double i3d image)
  2. Output image: convolved copy of input image inc. its metadata (resolution, offset, dimensions). The size of output image is changed.
  3. Return value: non-zero on error, otherwise zero (indicating no problem).

Specification:

Input image can be either 1D, 2D or 3D, the function will learn that from the filter.

Convolution mask is given by set of 1D arrays each of odd length (= center pixel + left and right parts of equal lengths). The corresponding filter would be constructed by convolving 2 or 3 arrays extended to 2D or 3D by zero-padding, i.e. only separable filters can be processed by this function.

In order to make output file of the same dimension as the input file, the input file must be extended by an border of specific size. The border data can be specified by border structure parameter. This enables one to supply own padding data. Border can also be specified by a border width separately for each direction/axis. In this case, each direction is extended by filling in constant value within the border.

The border width in given dimension times 2 plus 1 must be exactly the size of the corresponding filter.

Parameters:
[in]dconst reference to the input image
[out]resreference to the output image, the result
[in]fthe convolution filter
[in]bthe input image extension receipt

The convolution algorithm itself is cache targeted. It tries to maximize cache efficiency by limiting the necessary number of cache-misses. This is realized by applying several convolution masks at parallel. On the other hand, the memory consumption is also taken into account which results in just sub-optimal solution to the minimum cache-misses constraint.

Example:

Image3d<GRAY8> in(argv[1]);	//input image
Image3d<GRAY8> out;		//output image
Image3d<float> res,in_f;	//temporary higher-precision images

struct Separable3dFilter<float> f;
f.xData=new float[5];		//fill in the convolution filter
f.xData[0]=1.0;
f.xData[1]=4.0;
f.xData[2]=7.0;
f.xData[3]=4.0;
f.xData[4]=1.0;
f.xLength=5;
f.xDiv=17.0;

f.yData=f.xData;
f.yDiv=17.0;
f.yLength=5;

f.zData=f.xData;
f.zDiv=17.0;
f.zLength=5;

GrayToFloat(in,in_f);
in.DisposeData();

struct BorderPadding<float> b;
PrepareZeroBoundaryForFilter<float>(f,b); //fill in the extension borders

//compute the convolution
int ret=SeparableConvolution<float>(in_f,res,f,b);
in_f.DisposeData();

f.DisposeData();		//possibly free filter memory
b.DisposeData();		//possibly free paddings memory

if (ret == 0) {
	//no error
	FloatToGrayNoWeight(res,out);
	res.DisposeData();

	out.SaveImage(argv[2],IMG_TIFF);	//2D
	out.SaveImage(argv[2],IMG_ICSv2);		//3D
} else {
	//some error, filter sizes? memory?
}

//filter memory is freed automatically due to its destructors
Note:
Only float and double versions of this template are available, since GRAY8 suffers from voxel value overflows.
Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2007
template<class VOXEL >
int i3d::NaiveConvolution ( Image3d< VOXEL > const &  in,
Image3d< VOXEL > const &  kern,
Image3d< VOXEL > &  out,
const VOXEL  border = 0 
)

Full (naive) convolution of input image extended by given user constant.

This function performs a very simple and straightforward convolution: for every voxel of the input image it scans over all voxels in the kernel image resulting in the worst complexity convolution algorithm available. It is desirable to use any other (better) solution, e.g. separable filtering or Fourier transform, if available.

In order to keep the size of the convolved image out, the input image in shall be extended prior the convolution which squeezes the output image back to the size of the input image afterwards. The extension is virtual meaning that no temporary copy of the input image is created. Instead, the value of the parameter border is supplied to the convolution whenever a value of voxel outside the input image is required.

The convolution algorithm in its current implementation requires that all kernel image sizes be odd, e.q. (15,13,11) instead of (14,14,11).

Parameters:
[in]infloat or double input image
[in]kernconvolution kernel image of the same voxel type
[out]outconvolved copy of input image of the same voxel type
[in]borderoptionaly: voxel value with which input image is extended, default is zero
Returns:
  • 0 result returned correctly, no problem
  • -1 when kernel image has wrong size
  • -2 on memory allocation error
Note:
This function may, and probably will, consume an great deal of time before the result is returned. Perhaps one may like to use the progress reporting feature to make sure the function is really doing something.
Only float and double versions of this function are available, since GRAY8 suffers from voxel value overflows.
Author:
Vladimír Ulman (xulman@fi.muni.cz)
Date:
2009
template<typename T >
I3D_ALGO_EXPORT void i3d::MedianFilter ( const Image3d< T > &  img_in,
Image3d< T > &  img_out,
const Neighbourhood &  neib 
)

Apply median filter on image.

Applies median filter on the input image using given neighbourhood. Result is stored in the output image (this image is going to be resized according to the input). Boundary conditions are not solved in any way (just the available voxels are used for computation), if you wish to use for example neuman boundary condition, you have to padd the input image yourself. This function is currently faster than the one taking lat_radius and axi_radius (tested on the classical 3D 27-neighbourhood (26 + 1)).

Parameters:
[in]img_ininput image to be filtered
[out]img_outfiltered output of the input image
[in]neibneighbourhood in whitch to look for the median value for each image element
template<typename T >
I3D_ALGO_EXPORT void i3d::rankFilterByHistogram ( const i3d::Image3d< T > &  imgIn,
i3d::Image3d< T > &  imgOut,
Neighbourhood &  SEin,
int  rank 
)

Applies rank filter on the input image using given neighbourhood.

Apply rank filter on image.

Result is stored in the output image (this image is going to be resized according to the input).

Applies rank filter on the input image using given neighbourhood. Result is stored in the output image (this image is going to be resized according to the input).

Parameters:
[in]imgIninput image to be filtered
[out]imgOutfiltered output of the input image
[in]SEinStructural Element of rank filter in whitch we look for the desired value for each image element
[in]rankorder of element we choose from Structural Element
Author:
Radoslav Stefanik (256711@mail.muni.cz)
Date:
2010
template<class VOXEL , class PRECISION >
void i3d::GrayGaussIIR ( Image3d< VOXEL > &  img,
const PRECISION  Sigma 
)

A wrapper applying IIR Gaussian filter on an input grayscale image.

template<class VOXEL , class PRECISION >
void i3d::GrayGaussIIR ( Image3d< VOXEL > &  img,
const PRECISION  SigmaX,
const PRECISION  SigmaY,
const PRECISION  SigmaZ 
)

A wrapper applying IIR Gaussian filter on an input grayscale image.


Variable Documentation