[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]
![]() |
Kernel2D Class Template Reference | ![]() |
---|
Generic 2 dimensional convolution kernel. More...
#include "vigra/stdconvolution.hxx"
Public Types | |
typedef ARITHTYPE | value_type |
typedef BasicImage< value_type >::traverser | Iterator |
typedef BasicImage< value_type >::const_traverser | ConstIterator |
typedef BasicImage< value_type >::Accessor | Accessor |
typedef BasicImage< value_type >::ConstAccessor | ConstAccessor |
Public Methods | |
Kernel2D () | |
Kernel2D (Kernel2D const &k) | |
Kernel2D & | operator= (Kernel2D const &k) |
InitProxy | operator= (value_type const &v) |
~Kernel2D () | |
void | initSeparable (Kernel1D< value_type > &kx, Kernel1D< value_type > &ky) |
template<class KernelIterator> void | initSeparable (KernelIterator kxcenter, int xleft, int xright, KernelIterator kycenter, int yleft, int yright) |
void | initDisk (int radius) |
Kernel2D & | initExplicitly (Diff2D upperleft, Diff2D lowerright) |
Point2D | upperLeft () const |
Point2D | lowerRight () const |
int | width () const |
int | height () const |
Iterator | center () |
ConstIterator | center () const |
value_type & | operator() (int x, int y) |
value_type | operator() (int x, int y) const |
value_type | norm () const |
Accessor | accessor () |
ConstAccessor | accessor () const |
void | normalize (value_type norm) |
void | normalize () |
BorderTreatmentMode | borderTreatment () const |
void | setBorderTreatment (BorderTreatmentMode new_mode) |
Detailed Description |
This kernel may be used for convolution of 2 dimensional signals.
Convolution functions access the kernel via an ImageIterator which they get by calling center(). This iterator points to the center of the kernel. The kernel's size is given by its upperLeft() (upperLeft().x <= 0, upperLeft().y <= 0) and lowerRight() (lowerRight().x >= 0, lowerRight().y >= 0) methods. The desired border treatment mode is returned by borderTreatment(). (Note that the 2D convolution functions don't currently support all modes.)
The different init functions create a kernel with the specified properties. The requirements for the kernel's value_type depend on the init function used. At least NumericTraits must be defined.
The kernel defines a factory function kernel2d() to create an argument object (see Kernel Argument Object Factories).
Usage:
#include "vigra/stdconvolution.hxx"
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... // define horizontal Sobel filter vigra::Kernel2D<float> sobel; sobel.initExplicitly(Diff2D(-1,-1), Diff2D(1,1)) = // upper left and lower right 0.125, 0.0, -0.125, 0.25, 0.0, -0.25, 0.125, 0.0, -0.125; vigra::convolveImage(srcImageRange(src), destImage(dest), kernel2d(sobel));
Required Interface:
value_type v = NumericTraits<value_type>::one();
See also the init functions.
|
the kernel's accessor |
|
the kernel's const accessor |
|
const 2D random access iterator over the kernel's values |
|
2D random access iterator over the kernel's values |
|
the kernel's value type |
|
Default constructor. Creates a kernel of size 1x1 which would copy the signal unchanged. |
|
Copy constructor. |
|
Destructor. |
|
The kernels default const accessor. |
|
The kernels default accessor. |
|
current border treatment mode |
|
ImageIterator that points to the center of the kernel (coordinate (0,0)). |
|
ImageIterator that points to the center of the kernel (coordinate (0,0)). |
|
Height of the kernel. |
|
Init the 2D kernel as a circular averaging filter. The norm will be calculated as Required Interface:
value_type v = vigra::NumericTraits<value_type>::one(); double d; v = d * v; Precondition:
radius > 0; |
|
Init the kernel by an explicit initializer list. The upper left and lower right corners of the kernel must be passed. A comma-separated initializer list is given after the assignment operator. This function is used like this:
// define horizontal Sobel filter vigra::Kernel2D<float> sobel; sobel.initExplicitly(Diff2D(-1,-1), Diff2D(1,1)) = 0.125, 0.0, -0.125, 0.25, 0.0, -0.25, 0.125, 0.0, -0.125; The norm is set to the sum of the initialzer values. If the wrong number of values is given, a run-time error results. It is, however, possible to give just one initializer. This creates an averaging filter with the given constant:
vigra::Kernel2D<float> average3x3; average3x3.initExplicitly(Diff2D(-1,-1), Diff2D(1,1)) = 1.0/9.0; Here, the norm is set to value*width()*height(). Preconditions:
1. upperleft.x <= 0; 2. upperleft.y <= 0; 3. lowerright.x >= 0; 4. lowerright.y >= 0; 5. the number of values in the initializer list is 1 or equals the size of the kernel. |
|
Init the 2D kernel as the cartesian product of two 1D kernels given explicitly by iterators and sizes. The norm becomes the sum of the resulting kernel values. Required Interface: The kernel's value_type must be a linear algebra.
vigra::Kernel2D<...>::value_type v; v = v * v; v += v; Preconditions:
xleft <= 0; xright >= 0; yleft <= 0; yright >= 0; |
|
Init the 2D kernel as the cartesian product of two 1D kernels of type Kernel1D. The norm becomes the product of the two original norms. Required Interface: The kernel's value_type must be a linear algebra.
vigra::Kernel2D<...>::value_type v; v = v * v; |
|
Coordinates of the lower right corner of the kernel. |
|
Norm of the kernel (i.e. sum of its elements). |
|
Normalize the kernel to norm 1. |
|
Normalize the kernel to the given value. (The norm is the sum of all kernel elements.) The kernel's value_type must be a division algebra or algebraic field. Required Interface:
value_type v = vigra::NumericTraits<value_type>::one(); // if norm is not // given explicitly v += v; v = v * v; v = v / v; |
|
Read kernel entry at given position. |
|
Access kernel entry at given position. |
|
Initialisation. This initializes the kernel with the given constant. The norm becomes v*width()*height(). Instead of a single value an initializer list of length width()*height() can be used like this:
vigra::Kernel2D<float> binom; binom.initExplicitly(Diff2D(-1,-1), Diff2D(1,1)) = 0.0625, 0.125, 0.0625, 0.125, 0.25, 0.125, 0.0625, 0.125, 0.0625; In this case, the norm will be set to the sum of the init values. An initializer list of wrong length will result in a run-time error. |
|
Copy assignment. |
|
Set border treatment mode. Only |
|
Coordinates of the upper left corner of the kernel. |
|
Width of the kernel. |
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|