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 . 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 STD_SIGMA 0.84932180028801904272 |
STD_SIGMA == 1/sqrt(ln(4))
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.
[in] | img_in | input image |
[in] | kernel | convolution kernel (image) |
[out] | img_out | output (convolved) image, needn't be allocated |
[in] | normalize_kernel | ... query whether the kernel is to be normalized (optional parameter) |
void i3d::Convert | ( | Filter< NUMBER > & | out, |
const Filter< NUMBER2 > & | in | ||
) |
Filter conversion (to another arithmetic type):
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.
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().
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.
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.
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.
[in,out] | filter | reference to the filter structure to be filled in |
[in] | sigmaX | sigma of the Gauss filter's part along x-axis |
[in] | sigmaY | sigma of the Gauss filter's part along y-axis |
[in] | sigmaZ | sigma of the Gauss filter's part along z-axis |
[in] | widthX | width of the filter along x-axis which would be roundup(sigma*width)*2+1 in reality |
[in] | widthY | width of the filter along x-axis which would be roundup(sigma*width)*2+1 in reality |
[in] | widthZ | width of the filter along x-axis which would be roundup(sigma*width)*2+1 in reality |
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.
[in] | In | input Image3d<> |
[out] | Out | output (Gaussian blurred) Image3d<> |
[in] | Sigma | Sigma of the Gauss filter |
[in] | Width | Width of the Gauss filter |
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.
[in,out] | img | input and output (Gaussian blurred) Image3d<> |
[in] | Sigma | Sigma of the Gauss filter |
[in] | Width | Width of the Gauss filter |
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.
[in] | In | input Image3d<> |
[out] | Out | output (Gaussian blurred) Image3d<> |
[in] | SigmaX | Sigma of the Gauss filter along x-axis |
[in] | SigmaY | Sigma of the Gauss filter along y-axis |
[in] | SigmaZ | Sigma of the Gauss filter along z-axis |
[in] | WidthX | Width of the Gauss filter along x-axis |
[in] | WidthY | Width of the Gauss filter along y-axis |
[in] | WidthZ | Width of the Gauss filter along z-axis |
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.
[in,out] | img | input and output (Gaussian blurred) Image3d<> |
[in] | SigmaX | Sigma of the Gauss filter along x-axis |
[in] | SigmaY | Sigma of the Gauss filter along y-axis |
[in] | SigmaZ | Sigma of the Gauss filter along z-axis |
[in] | WidthX | Width of the Gauss filter along x-axis |
[in] | WidthY | Width of the Gauss filter along y-axis |
[in] | WidthZ | Width of the Gauss filter along z-axis |
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.
[in,out] | img | input and output (Gaussian blurred) Image3d<> |
[in] | Sigma | Sigma 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.
The function is instantiated only for voxel types float
and double
.
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.
[in,out] | img | input and output (Gaussian blurred) Image3d<> |
[in] | SigmaX | Sigma of the Gauss filter along x-axis |
[in] | SigmaY | Sigma of the Gauss filter along y-axis |
[in] | SigmaZ | Sigma 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.
The function is instantiated only for voxel types float
and double
.
void i3d::SuppresHotPixels | ( | const Image3d< T > & | in, |
Image3d< T > & | out, | ||
const Neighbourhood & | neib, | ||
T | 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.
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.
[in] | filter | reference to a filter to be filtered with |
[in,out] | b | reference to the paddings structure |
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.
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.
[in] | d | const reference to the input image |
[out] | res | reference to the output image, the result |
[in] | f | the convolution filter |
[in] | b | the 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
float
and double
versions of this template are available, since GRAY8
suffers from voxel value overflows. 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).
[in] | in | float or double input image |
[in] | kern | convolution kernel image of the same voxel type |
[out] | out | convolved copy of input image of the same voxel type |
[in] | border | optionaly: voxel value with which input image is extended, default is zero |
float
and double
versions of this function are available, since GRAY8
suffers from voxel value overflows.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)).
[in] | img_in | input image to be filtered |
[out] | img_out | filtered output of the input image |
[in] | neib | neighbourhood in whitch to look for the median value for each image element |
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).
[in] | imgIn | input image to be filtered |
[out] | imgOut | filtered output of the input image |
[in] | SEin | Structural Element of rank filter in whitch we look for the desired value for each image element |
[in] | rank | order of element we choose from Structural Element |
void i3d::GrayGaussIIR | ( | Image3d< VOXEL > & | img, |
const PRECISION | Sigma | ||
) |
A wrapper applying IIR Gaussian filter on an input grayscale image.
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.