Processing
The Processing module provides useful standard signal processing
operations such as convolution and correlation.
Processing can be used with either Matrix, boost's
multi_array,
or with Blitz++'s
Array through BlitzArray.
Interface
Convolution and correlation are implemented in the frequency-domain, using
Fourier-transforms. Therefor Fourier.
In order to enable parallel processing, use either
OpenMP or define USE_THREADS, but,
following the
relevant section of the FFTW manual, preferably not both. If neither are
defined, the parameter threads will be ignored. The threads
parameter refers to the number of threads used by the system threads library,
which requires linking extra libraries as explained in the documentation of
Fourier.
bool convolute( const Array_t<Tlhs, N> &lhs,
const Array_t<Trhs, N> &rhs,
Array_t<Tresult, N> &result,
unsigned threads = 0u)
|
Convolution of two N-dimensional arrays lhs and
rhs using threads threads. On exit, result will
have been resized to the desired dimensions.
|
bool convolute( const Array_t<Tlhs, N> &lhs,
const std::vector<Array_t<Trhs, N> > &rhs,
std::vector<Array_t<Tresult, N> > &result,
unsigned threads = 0u)
|
Convolution of N-dimensional arrays lhs and
all arrays in the vector in rhs using threads threads.
On exit, result will contain as many arrays as rhs,
each will have been resized to the desired dimensions. Each array in
result will be a convolution of the array in rhs with
the same index, and lhs.
|
bool correlate( const Array_t<Tlhs, N> &lhs,
const Array_t<Trhs, N> &rhs,
Array_t<Tresult, N> &result,
unsigned threads = 0u)
|
Correlation of two N-dimensional arrays lhs and
rhs using threads threads. On exit, result will
have been resized to the desired dimensions.
|
bool correlate( const Array_t<Tlhs, N> &lhs,
const std::vector<Array_t<Trhs, N> > &rhs,
std::vector<Array_t<Tresult, N> > &result,
unsigned threads = 0u)
|
Correlation of N-dimensional arrays lhs and
all arrays in the vector in rhs using threads threads.
On exit, result will contain as many arrays as rhs,
each will have been resized to the desired dimensions. Each array in
result will be a correlation between the array in rhs with
the same index, and lhs.
|
bool autocorrelate(const Array_t<Tlhs, N> &lhs,
Array_t<Tresult, N> &result,
unsigned threads = 0u)
|
Auto-correlation of two N-dimensional array lhs,
calculated using threads threads. On exit, result will
have been resized to the desired dimensions.
|
bool autocorrelate(const std::vector<Array_t<Trhs, N> > &lhs,
std::vector<Array_t<Tresult, N> > &result,
unsigned threads = 0u)
|
Auto-correlation of all N-dimensional arrays in lhs,
calculated using threads threads.
On exit, result will contain as many arrays as lhs,
each will have been resized to the desired dimensions.
|
bool localAvg( Array_t<Tlhs, N> &lhs, const int radius,
Array_t<Tresult, N> &result,
unsigned threads = 0u)
|
Computes the local average for all elements in lhs using
threads threads. On exit, result will
have been resized to the dimensions of lhs.
|
bool localAvg( std::vector<Array_t<Tlhs, N> > &lhs, const int radius,
std::vector<Array_t<Tresult, N> > &result,
unsigned threads = 0u)
|
Computes the local average for all elements in all N-dimensional
arrays in lhs using threads threads. On exit,
result will contain N-dimensional arrays representing the
local averages, each one will be resized to the dimensions of the items in lhs.
|
Examples
Convolution
const unsigned dims [] = {256u, 256u};
Matrix<int, 2u> image(dims);
// Read image
...
const unsigned maskDims [] = {5, 5};
Matrix<float, 2u> mask(maskDims, 1.0/25.0);
Matrix<float, 2u> result(dims);
// Convolute
const bool ok = convolute(image, mask, result);
|