Classes | Defines | Enumerations | Functions
core/vil/algo/vil_convolve_1d.h File Reference

1D Convolution with cunning boundary options More...

#include <vcl_compiler.h>
#include <vcl_algorithm.h>
#include <vcl_cstdlib.h>
#include <vcl_cstring.h>
#include <vcl_cassert.h>
#include <vcl_iostream.h>
#include <vil/vil_image_view.h>
#include <vil/vil_image_resource.h>
#include <vil/vil_property.h>

Go to the source code of this file.

Classes

class  vil_convolve_1d_resource< kernelT, accumT, destT >
 A resource adaptor that behaves like a convolved version of its input. More...

Defines

#define macro(F, T)

Enumerations

enum  vil_convolve_boundary_option {
  vil_convolve_ignore_edge, vil_convolve_no_extend, vil_convolve_zero_extend, vil_convolve_constant_extend,
  vil_convolve_periodic_extend, vil_convolve_reflect_extend, vil_convolve_trim
}
 Available options for boundary behavior. More...

Functions

template<class srcT , class destT , class kernelT , class accumT >
void vil_convolve_edge_1d (const srcT *src, unsigned n, vcl_ptrdiff_t s_step, destT *dest, vcl_ptrdiff_t d_step, const kernelT *kernel, vcl_ptrdiff_t k_lo, vcl_ptrdiff_t k_hi, vcl_ptrdiff_t kstep, accumT, vil_convolve_boundary_option option)
 Convolve edge with kernel[x*kstep] x in [k_lo,k_hi] (k_hi>=0).
template<class srcT , class destT , class kernelT , class accumT >
void vil_convolve_1d (const srcT *src0, unsigned nx, vcl_ptrdiff_t s_step, destT *dest0, vcl_ptrdiff_t d_step, const kernelT *kernel, vcl_ptrdiff_t k_lo, vcl_ptrdiff_t k_hi, accumT ac, vil_convolve_boundary_option start_option, vil_convolve_boundary_option end_option)
 Convolve kernel[x] (x in [k_lo,k_hi]) with srcT.
template<class srcT , class destT , class kernelT , class accumT >
void vil_convolve_1d (const vil_image_view< srcT > &src_im, vil_image_view< destT > &dest_im, const kernelT *kernel, vcl_ptrdiff_t k_lo, vcl_ptrdiff_t k_hi, accumT ac, vil_convolve_boundary_option start_option, vil_convolve_boundary_option end_option)
 Convolve kernel[i] (i in [k_lo,k_hi]) with srcT in i-direction.
template<class destT , class kernelT , class accumT >
vil_image_resource_sptr vil_convolve_1d (const vil_image_resource_sptr &src_im, const destT, const kernelT *kernel, int k_lo, int k_hi, const accumT, vil_convolve_boundary_option start_option, vil_convolve_boundary_option end_option)
 Create an image_resource object which convolve kernel[x] x in [k_lo,k_hi] with srcT.

Detailed Description

1D Convolution with cunning boundary options

Author:
Tim Cootes, Ian Scott (based on work by fsm)
Note:
The convolution operation is defined by $(f*g)(x) = \int f(x-y) g(y) dy$ i.e. the kernel g is reflected before the integration is performed. If you don't want this to happen, the behaviour you want is not called "convolution". So don't break the convolution routines in that particular way.

Definition in file vil_convolve_1d.h.

Define Documentation

#define macro (   F,
  T 
)
Value:
case F : \
      vil_convolve_1d(static_cast<vil_image_view<T >&>(*vs),dest, \
                      kernel_, klo_, khi_, accumT(), start_option_, end_option_); \
      return new vil_image_view<destT>(vil_crop(dest, lboundary, n_i, 0, n_j));

Enumeration Type Documentation

enum vil_convolve_boundary_option

Available options for boundary behavior.

When convolving a finite signal the boundaries may be treated in various ways which can often be expressed in terms of ways to extend the signal outside its original range.

Enumerator:
vil_convolve_ignore_edge 

Do not fill destination edges at all.

i.e. leave them unchanged.

vil_convolve_no_extend 

Do not to extend the signal, but pad with zeros. 

       |                               |
   K                       ----*-------
   in   ... ---------------------------
   out  ... --------------------0000000
vil_convolve_zero_extend 

Zero-extend the input signal beyond the boundary. 

       |                               |
   K                              ----*--------
   in   ... ---------------------------000000000000...
   out  ... ---------------------------
vil_convolve_constant_extend 

Extend the signal to be constant beyond the boundary. 

       |                               |
   K                              ----*--------
   in   ... --------------------------aaaaaaaaaaaaa...
   out  ... ---------------------------
vil_convolve_periodic_extend 

Extend the signal periodically beyond the boundary. 

       |                               |
   K                              ----*--------
   in   abc...-------------------------abc...------..
   out  ... ---------------------------
vil_convolve_reflect_extend 

Extend the signal by reflection about the boundary. 

       |                               |
   K                              ----*--------
   in   ... -------------------...edcbabcde...
   out  ... ---------------------------
vil_convolve_trim 

Kernel is trimmed and reweighed, to allow convolution up to boundary.

This one is slightly different. The input signal is not extended in any way, but the kernel is trimmed to allow convolution to proceed up to the boundary and reweighed to keep the total area the same.

Note:
may not work with kernels which take negative values.

Definition at line 31 of file vil_convolve_1d.h.

Function Documentation

template<class srcT , class destT , class kernelT , class accumT >
void vil_convolve_1d ( const srcT *  src0,
unsigned  nx,
vcl_ptrdiff_t  s_step,
destT *  dest0,
vcl_ptrdiff_t  d_step,
const kernelT *  kernel,
vcl_ptrdiff_t  k_lo,
vcl_ptrdiff_t  k_hi,
accumT  ac,
vil_convolve_boundary_option  start_option,
vil_convolve_boundary_option  end_option 
) [inline]

Convolve kernel[x] (x in [k_lo,k_hi]) with srcT.

Assumes dest and src same size (nx) Kernel must not be larger than nx;

Definition at line 201 of file vil_convolve_1d.h.

template<class srcT , class destT , class kernelT , class accumT >
void vil_convolve_1d ( const vil_image_view< srcT > &  src_im,
vil_image_view< destT > &  dest_im,
const kernelT *  kernel,
vcl_ptrdiff_t  k_lo,
vcl_ptrdiff_t  k_hi,
accumT  ac,
vil_convolve_boundary_option  start_option,
vil_convolve_boundary_option  end_option 
) [inline]

Convolve kernel[i] (i in [k_lo,k_hi]) with srcT in i-direction.

On exit dest_im(i,j) = sum src(i-x,j)*kernel(x) (x=k_lo..k_hi)

Note:
This function reverses the kernel. If you don't want the kernel reversed, use vil_correlate_1d instead. The kernel must not be larger than src_im.ni()
Parameters:
kernelshould point to tap 0.
dest_imwill be resized to size of src_im.

Definition at line 246 of file vil_convolve_1d.h.

template<class destT , class kernelT , class accumT >
vil_image_resource_sptr vil_convolve_1d ( const vil_image_resource_sptr &  src_im,
const destT  ,
const kernelT *  kernel,
int  k_lo,
int  k_hi,
const accumT  ,
vil_convolve_boundary_option  start_option,
vil_convolve_boundary_option  end_option 
)

Create an image_resource object which convolve kernel[x] x in [k_lo,k_hi] with srcT.

Note:
This function reverses the kernel. If you don't want the kernel reversed, use vil_correlate_1d instead.
Parameters:
kernelshould point to tap 0.

Definition at line 403 of file vil_convolve_1d.h.

template<class srcT , class destT , class kernelT , class accumT >
void vil_convolve_edge_1d ( const srcT *  src,
unsigned  n,
vcl_ptrdiff_t  s_step,
destT *  dest,
vcl_ptrdiff_t  d_step,
const kernelT *  kernel,
vcl_ptrdiff_t  k_lo,
vcl_ptrdiff_t  k_hi,
vcl_ptrdiff_t  kstep,
accumT  ,
vil_convolve_boundary_option  option 
) [inline]

Convolve edge with kernel[x*kstep] x in [k_lo,k_hi] (k_hi>=0).

Fills only edge: dest[i], i=0..(k_hi-1)

Definition at line 94 of file vil_convolve_1d.h.

Generated on Wed May 1 2013 17:31:49 for core/vil by   doxygen 1.7.5.1