convolution.h File Reference

#include <vector>
#include <memory>
#include <numeric>
#include <algorithm>
#include <cvd/config.h>
#include <cvd/exceptions.h>
#include <cvd/image.h>
#include <cvd/internal/pixel_operations.h>
#include <cmath>
#include <cvd/internal/pixel_traits.h>
#include <cvd/internal/convert_pixel_types.h>
#include <cvd/internal/builtin_components.h>
#include <cvd/internal/rgb_components.h>
#include <cvd/internal/aligned_mem.h>
#include <cvd/internal/is_pod.h>
#include <sys/types.h>

Include dependency graph for convolution.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	CVD::Exceptions::Convolution::All
struct	CVD::CastCopy< T, S >
struct	CVD::CastCopy< T, T >
struct	CVD::ConvolveMiddle< T, N, C >
struct	CVD::ConvolveMiddle< T, 0, 1 >
struct	CVD::ConvolveMiddle< T, N, 1 >
struct	CVD::ConvolveMiddle< T,-1, 1 >
struct	CVD::ConvolveMiddle< T,-1, C >
struct	CVD::GetPixelRowTyped< A, B >
struct	CVD::GetPixelRowTyped< T, T >
struct	CVD::Exceptions::Convolution::IncompatibleImageSizes
struct	CVD::Exceptions::Convolution::OddSizedKernelRequired
Namespaces
namespace	CVD
namespace	CVD::Exceptions
namespace	CVD::Exceptions::Convolution
Defines
#define	CALL_CM(I)   for (int j=0; j<n; ++j, ++input, ++output) { *output = ConvolveMiddle<T,I>::at(input, factor, kernel); } break
Functions
template<class T , class S >
void	CVD::cast_copy (const T *from, S *to, int count)
void	CVD::compute_triggs_M (const double b[], double M[][3])
void	CVD::compute_van_vliet_b (double sigma, double b[])
template<class T , class O , class K >
void	CVD::convolve_gaussian_3 (const BasicImage< T > &I, BasicImage< O > &out, K k1, K k2)
void	CVD::convolveGaussian (const BasicImage< float > &I, BasicImage< float > &out, double sigma, double sigmas=3.0)
template<class T >
void	CVD::convolveGaussian (const BasicImage< T > &I, BasicImage< T > &out, double sigma, double sigmas=3.0)
template<class T >
void	CVD::convolveGaussian (BasicImage< T > &I, double sigma, double sigmas=3.0)
template<class T >
void	CVD::convolveGaussian5_1 (BasicImage< T > &I)
void	CVD::convolveGaussian_fir (const BasicImage< float > &I, BasicImage< float > &out, double sigma, double sigmas=3.0)
template<class T , class S >
const T *	CVD::convolveMiddle (const T *input, const S &factor, const S *kernel, int ksize, int n, T *output)
template<class T , class K >
void	CVD::convolveSeparableSymmetric (Image< T > &I, const std::vector< K > &kernel, K divisor)
template<class T , int A, int B, int C, int D>
void	CVD::convolveSymmetric (Image< T > &I)
template<class T , int A, int B, int C>
void	CVD::convolveSymmetric (Image< T > &I)
template<class T >
void	CVD::convolveWithBox (BasicImage< T > &I, ImageRef hwin)
template<class T >
void	CVD::convolveWithBox (BasicImage< T > &I, int hwin)
template<class T >
void	CVD::convolveWithBox (const BasicImage< T > &I, BasicImage< T > &J, int hwin)
template<class T >
void	CVD::convolveWithBox (const BasicImage< T > &I, BasicImage< T > &J, ImageRef hwin)
template<class T >
T	CVD::gaussianKernel (std::vector< T > &k, T maxval, double stddev)
template<class A , class B >
const B *	CVD::getPixelRowTyped (const A *row, int n, B *rowbuf)
template<class S , class T >
T	CVD::scaleKernel (const std::vector< S > &k, std::vector< T > &scaled, T maxval)
void	CVD::van_vliet_blur (const double b[], const SubImage< float > in, SubImage< float > out)

---

Define Documentation

#define CALL_CM

(

I

)

for (int j=0; j<n; ++j, ++input, ++output) { *output = ConvolveMiddle<T,I>::at(input, factor, kernel); } break