[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
![]() |
Recursive convolution functions | ![]() |
Functions | |
template<... > | |
void | recursiveFilterLine (...) |
Performs a 1-dimensional recursive convolution of the source signal. | |
template<... > | |
void | recursiveFilterX (...) |
Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction. | |
template<... > | |
void | recursiveFilterY (...) |
Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction. | |
template<... > | |
void | recursiveFirstDerivativeLine (...) |
Performs a 1 dimensional recursive convolution of the source signal. | |
template<... > | |
void | recursiveFirstDerivativeX (...) |
Recursively calculates the 1 dimensional first derivative in x direction. | |
template<... > | |
void | recursiveFirstDerivativeY (...) |
Recursively calculates the 1 dimensional first derivative in y direction. | |
template<... > | |
void | recursiveGaussianFilterLine (...) |
Compute a 1-dimensional recursive approximation of Gaussian smoothing. | |
template<... > | |
void | recursiveGaussianFilterX (...) |
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction. | |
template<... > | |
void | recursiveGaussianFilterY (...) |
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction. | |
template<... > | |
void | recursiveSecondDerivativeLine (...) |
Performs a 1 dimensional recursive convolution of the source signal. | |
template<... > | |
void | recursiveSecondDerivativeX (...) |
Recursively calculates the 1 dimensional second derivative in x direction. | |
template<... > | |
void | recursiveSecondDerivativeY (...) |
Recursively calculates the 1 dimensional second derivative in y direction. | |
template<... > | |
void | recursiveSmoothLine (...) |
Convolves the image with a 1-dimensional exponential filter. | |
template<... > | |
void | recursiveSmoothX (...) |
Performs 1 dimensional recursive smoothing in x direction. | |
template<... > | |
void | recursiveSmoothY (...) |
Performs 1 dimensional recursive smoothing in y direction. |
template<... > | |||||
void vigra::recursiveFilterLine | ( | ... | ) |
Performs a 1-dimensional recursive convolution of the source signal.
The function performs a causal and an anti-causal first or second order recursive filtering with the given filter parameter b1
and border treatment border
(first order filter, b2 = 0
) or parameters b1, b2
and BORDER_TREATMENT_REFLECT
(second order filter). Thus, the result is always a filtering with linear phase.
The signal's value_type (SrcAccessor::value_type) must be a linear space over double
, i.e. addition of source values, multiplication with double
, and NumericTraits
must be defined.
Declaration:
First order recursive filter:
namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void recursiveFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double b1, BorderTreatmentMode border) }
Second order recursive filter:
namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void recursiveFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double b1, double b2) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vector<float> src, dest; ... vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor; vigra::recursiveFilterLine(src.begin(), src.end(), FAccessor(), dest.begin(), FAccessor(), 0.5, BORDER_TREATMENT_REFLECT);
Required Interface:
RandomAccessIterator is, isend; RandomAccessIterator id; SrcAccessor src_accessor; DestAccessor dest_accessor; NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is); double d; s = s + s; s = d * s; dest_accessor.set( NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
Preconditions:
-1 < b < 1
template<... > | |||||
void vigra::recursiveGaussianFilterLine | ( | ... | ) |
Compute a 1-dimensional recursive approximation of Gaussian smoothing.
The function applies a causal and an anti-causal third order recursive filter which optimally approximates the Gaussian filter, as proposed in
I. Young, L. van Vliet: Recursive implementation of the Gaussian filter
Signal Processing 44:139-151, 1995
The formulas for transforming the given scale parameter sigma
into the actual filter coefficients are taken from Luigi Rosa's Matlab implementation.
The signal's value_type (SrcAccessor::value_type) must be a linear space over double
, i.e. addition of source values, multiplication with double
, and NumericTraits
must be defined.
Declaration:
namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void recursiveGaussianFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double sigma); }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vector<float> src, dest; ... vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor; double sigma = 2.5; vigra::recursiveGaussianFilterLine(src.begin(), src.end(), FAccessor(), dest.begin(), FAccessor(), sigma);
Required Interface:
RandomAccessIterator is, isend; RandomAccessIterator id; SrcAccessor src_accessor; DestAccessor dest_accessor; NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is); double d; s = s + s; s = d * s; dest_accessor.set( NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
Preconditions:
0 <= sigma (absolute values are used for negative sigma)
template<... > | |||||
void vigra::recursiveSmoothLine | ( | ... | ) |
Convolves the image with a 1-dimensional exponential filter.
This function calls recursiveFilterLine() with b = exp(-1.0/scale)
and border = BORDER_TREATMENT_REPEAT
. See recursiveFilterLine() for more documentation.
Declaration:
namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void recursiveSmoothLine(SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vector<float> src, dest; ... vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor; vigra::recursiveSmoothLine(src.begin(), src.end(), FAccessor(), dest.begin(), FAccessor(), 3.0);
Required Interface:
RandomAccessIterator is, isend; RandomAccessIterator id; SrcAccessor src_accessor; DestAccessor dest_accessor; NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is); double d; s = s + s; s = d * s; dest_accessor.set( NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
Preconditions:
scale > 0
template<... > | |||||
void vigra::recursiveFirstDerivativeLine | ( | ... | ) |
Performs a 1 dimensional recursive convolution of the source signal.
It uses the first derivative an exponential d/dx exp(-abs(x)/scale)
as a kernel. The signal's value_type (SrcAccessor::value_type) must be a linear space over double
, i.e. addition and subtraction of source values, multiplication with double
, and NumericTraits
must be defined. Border treatment is always BORDER_TREATMENT_REPEAT
.
Declaration:
namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void recursiveFirstDerivativeLine(SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vector<float> src, dest; ... vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor; vigra::recursiveFirstDerivativeLine(src.begin(), src.end(), FAccessor(), dest.begin(), FAccessor(), 3.0);
Required Interface:
RandomAccessIterator is, isend; RandomAccessIterator id; SrcAccessor src_accessor; DestAccessor dest_accessor; NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is); double d; s = s + s; s = -s; s = d * s; dest_accessor.set( NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
Preconditions:
scale > 0
template<... > | |||||
void vigra::recursiveSecondDerivativeLine | ( | ... | ) |
Performs a 1 dimensional recursive convolution of the source signal.
It uses the second derivative an exponential d2/dx2 exp(-abs(x)/scale)
as a kernel. The signal's value_type (SrcAccessor::value_type) must be a linear space over double
, i.e. addition and subtraction of source values, multiplication with double
, and NumericTraits
must be defined. Border treatment is always BORDER_TREATMENT_REPEAT
.
Declaration:
namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void recursiveSecondDerivativeLine(SrcIterator is, SrcIterator isend, SrcAccessor as, DestIterator id, DestAccessor ad, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vector<float> src, dest; ... vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor; vigra::recursiveSecondDerivativeLine(src.begin(), src.end(), FAccessor(), dest.begin(), FAccessor(), 3.0);
Required Interface:
RandomAccessIterator is, isend; RandomAccessIterator id; SrcAccessor src_accessor; DestAccessor dest_accessor; NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is); double d; s = s + s; s = s - s; s = d * s; dest_accessor.set( NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
Preconditions:
scale > 0
template<... > | |||||
void vigra::recursiveFilterX | ( | ... | ) |
Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction.
It calls recursiveFilterLine() for every row of the image. See recursiveFilterLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { // first order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double b, BorderTreatmentMode border); // second order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double b1, double b2); }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { // first order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterX( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double b, BorderTreatmentMode border); // second order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterX( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double b1, double b2); }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveSmoothX(srcImageRange(src), destImage(dest), 0.5, BORDER_TREATMENT_REFLECT);
template<... > | |||||
void vigra::recursiveGaussianFilterX | ( | ... | ) |
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
It calls recursiveGaussianFilterLine() for every column of the image. See recursiveGaussianFilterLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveGaussianFilterX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double sigma); }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveGaussianFilterX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double sigma); }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveGaussianFilterX(srcImageRange(src), destImage(dest), 3.0);
template<... > | |||||
void vigra::recursiveSmoothX | ( | ... | ) |
Performs 1 dimensional recursive smoothing in x direction.
It calls recursiveSmoothLine() for every row of the image. See recursiveSmoothLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSmoothX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale) }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSmoothX( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveSmoothX(srcImageRange(src), destImage(dest), 3.0);
template<... > | |||||
void vigra::recursiveFilterY | ( | ... | ) |
Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction.
It calls recursiveFilterLine() for every column of the image. See recursiveFilterLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { // first order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double b, BorderTreatmentMode border); // second order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double b1, double b2); }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { // first order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterY( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double b, BorderTreatmentMode border); // second order filter template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFilterY( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double b1, double b2); }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveFilterY(srcImageRange(src), destImage(dest), -0.6, -0.06);
template<... > | |||||
void vigra::recursiveGaussianFilterY | ( | ... | ) |
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
It calls recursiveGaussianFilterLine() for every column of the image. See recursiveGaussianFilterLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveGaussianFilterY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double sigma); }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveGaussianFilterY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double sigma); }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveGaussianFilterY(srcImageRange(src), destImage(dest), 3.0);
template<... > | |||||
void vigra::recursiveSmoothY | ( | ... | ) |
Performs 1 dimensional recursive smoothing in y direction.
It calls recursiveSmoothLine() for every column of the image. See recursiveSmoothLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSmoothY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale) }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSmoothY( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveSmoothY(srcImageRange(src), destImage(dest), 3.0);
template<... > | |||||
void vigra::recursiveFirstDerivativeX | ( | ... | ) |
Recursively calculates the 1 dimensional first derivative in x direction.
It calls recursiveFirstDerivativeLine() for every row of the image. See recursiveFirstDerivativeLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFirstDerivativeX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale) }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFirstDerivativeX( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveFirstDerivativeX(srcImageRange(src), destImage(dest), 3.0);
template<... > | |||||
void vigra::recursiveFirstDerivativeY | ( | ... | ) |
Recursively calculates the 1 dimensional first derivative in y direction.
It calls recursiveFirstDerivativeLine() for every column of the image. See recursiveFirstDerivativeLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFirstDerivativeY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale) }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveFirstDerivativeY( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveFirstDerivativeY(srcImageRange(src), destImage(dest), 3.0);
template<... > | |||||
void vigra::recursiveSecondDerivativeX | ( | ... | ) |
Recursively calculates the 1 dimensional second derivative in x direction.
It calls recursiveSecondDerivativeLine() for every row of the image. See recursiveSecondDerivativeLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSecondDerivativeX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale) }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSecondDerivativeX( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveSecondDerivativeX(srcImageRange(src), destImage(dest), 3.0);
template<... > | |||||
void vigra::recursiveSecondDerivativeY | ( | ... | ) |
Recursively calculates the 1 dimensional second derivative in y direction.
It calls recursiveSecondDerivativeLine() for every column of the image. See recursiveSecondDerivativeLine() for more information about required interfaces and vigra_preconditions.
Declarations:
pass arguments explicitly:
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSecondDerivativeY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as, DestImageIterator dupperleft, DestAccessor ad, double scale) }
use argument objects in conjunction with Argument Object Factories :
namespace vigra { template <class SrcImageIterator, class SrcAccessor, class DestImageIterator, class DestAccessor> void recursiveSecondDerivativeY( triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, pair<DestImageIterator, DestAccessor> dest, double scale) }
Usage:
#include <vigra/recursiveconvolution.hxx>
Namespace: vigra
vigra::FImage src(w,h), dest(w,h); ... vigra::recursiveSecondDerivativeY(srcImageRange(src), destImage(dest), 3.0);
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|