Recursive convolution functions

Functions
template<... >
void	recursiveFilterLine (...)
	Performs a 1-dimensional recursive convolution of the source signal. More...
template<... >
void	recursiveFilterX (...)
	Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction. More...
template<... >
void	recursiveFilterY (...)
	Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction. More...
template<... >
void	recursiveFirstDerivativeLine (...)
	Performs a 1 dimensional recursive convolution of the source signal. More...
template<... >
void	recursiveFirstDerivativeX (...)
	Recursively calculates the 1 dimensional first derivative in x direction. More...
template<... >
void	recursiveFirstDerivativeY (...)
	Recursively calculates the 1 dimensional first derivative in y direction. More...
template<... >
void	recursiveGaussianFilterLine (...)
	Compute a 1-dimensional recursive approximation of Gaussian smoothing. More...
template<... >
void	recursiveGaussianFilterX (...)
	Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction. More...
template<... >
void	recursiveGaussianFilterY (...)
	Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction. More...
template<... >
void	recursiveSecondDerivativeLine (...)
	Performs a 1 dimensional recursive convolution of the source signal. More...
template<... >
void	recursiveSecondDerivativeX (...)
	Recursively calculates the 1 dimensional second derivative in x direction. More...
template<... >
void	recursiveSecondDerivativeY (...)
	Recursively calculates the 1 dimensional second derivative in y direction. More...
template<... >
void	recursiveSmoothLine (...)
	Convolves the image with a 1-dimensional exponential filter. More...
template<... >
void	recursiveSmoothX (...)
	Performs 1 dimensional recursive smoothing in x direction. More...
template<... >
void	recursiveSmoothY (...)
	Performs 1 dimensional recursive smoothing in y direction. More...

Detailed Description

First order recursive filters and their specialization for the exponential filter and its derivatives (1D and separable 2D). These filters are very fast, and the speed does not depend on the filter size.

Function Documentation

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;    
...

DefaultAccessor<vector<float>::iterator, float> FAccessor;


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

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)

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

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

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

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 2D array views:

namespace vigra {
    // first order filter
    template <class T1, class S1,
              class T2, class S2>
    void 
    recursiveFilterX(MultiArrayView<2, T1, S1> const & src,
                     MultiArrayView<2, T2, S2> dest, 
                     double b, BorderTreatmentMode border);
                     
    // second order filter
    template <class T1, class S1,
              class T2, class S2>
    void 
    recursiveFilterX(MultiArrayView<2, T1, S1> const & src,
                     MultiArrayView<2, T2, S2> dest, 
                     double b1, double b2);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

// apply a first-order filter to the x-axis
recursiveFilterX(src, dest, 0.5, BORDER_TREATMENT_REFLECT);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveFilterX(srcImageRange(src), destImage(dest), 
       0.5, BORDER_TREATMENT_REFLECT);

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void 
    recursiveGaussianFilterX(MultiArrayView<2, T1, S1> const & src,
                             MultiArrayView<2, T2, S2> dest, 
                             double sigma);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveGaussianFilterX(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveGaussianFilterX(srcImageRange(src), destImage(dest), 3.0);

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    recursiveSmoothX(MultiArrayView<2, T1, S1> const & src,
                     MultiArrayView<2, T2, S2> dest, 
                     double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveSmoothX(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveSmoothX(srcImageRange(src), destImage(dest), 3.0);

Examples:

smooth.cxx.

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 2D array views:

namespace vigra {
    // first order filter
    template <class T1, class S1,
              class T2, class S2>
    void
    recursiveFilterY(MultiArrayView<2, T1, S1> const & src,
                     MultiArrayView<2, T2, S2> dest, 
                     double b, BorderTreatmentMode border);
                     
    // second order filter
    template <class T1, class S1,
              class T2, class S2>
    void
    recursiveFilterY(MultiArrayView<2, T1, S1> const & src,
                     MultiArrayView<2, T2, S2> dest, 
                     double b1, double b2);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

// apply a second-order filter to the y-axis
recursiveFilterY(src, dest, -0.6, -0.06);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveFilterY(srcImageRange(src), destImage(dest), -0.6, -0.06);

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void 
    recursiveGaussianFilterY(MultiArrayView<2, T1, S1> const & src,
                             MultiArrayView<2, T2, S2> dest, 
                             double sigma);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveGaussianFilterY(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveGaussianFilterY(srcImageRange(src), destImage(dest), 3.0);

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void 
    recursiveSmoothY(MultiArrayView<2, T1, S1> const & src,
                     MultiArrayView<2, T2, S2> dest, 
                     double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveSmoothY(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveSmoothY(srcImageRange(src), destImage(dest), 3.0);

Examples:

smooth.cxx.

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    recursiveFirstDerivativeX(MultiArrayView<2, T1, S1> const & src,
                              MultiArrayView<2, T2, S2> dest, 
                              double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveFirstDerivativeX(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveFirstDerivativeX(srcImageRange(src), destImage(dest), 3.0);

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    recursiveFirstDerivativeY(MultiArrayView<2, T1, S1> const & src,
                              MultiArrayView<2, T2, S2> dest, 
                              double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveFirstDerivativeY(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveFirstDerivativeY(srcImageRange(src), destImage(dest), 3.0);

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    recursiveSecondDerivativeX(MultiArrayView<2, T1, S1> const & src,
                               MultiArrayView<2, T2, S2> dest, 
                               double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveSecondDerivativeX(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveSecondDerivativeX(srcImageRange(src), destImage(dest), 3.0);

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 2D array views:

namespace vigra {
    template <class T1, class S1,
              class T2, class S2>
    void
    recursiveSecondDerivativeY(MultiArrayView<2, T1, S1> const & src,
                               MultiArrayView<2, T2, S2> dest, 
                               double scale);
}

show deprecated declarations

pass Image Iterators and Data Accessors :

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

MultiArray<2, float> src(w,h), dest(w,h);    
...

recursiveSecondDerivativeY(src, dest, 3.0);

show deprecated examples

vigra::FImage src(w,h), dest(w,h);    
...

vigra::recursiveSecondDerivativeY(srcImageRange(src), destImage(dest), 3.0);