CVD Namespace Reference

Namespaces

namespace  BMP
namespace  ColourSpace
 

Internal colourspace conversions.


namespace  CVDimage
namespace  DC
 

Internal DVBuffer2 helpers.


namespace  DV3
 

Internal DVBuffer3 helpers.


namespace  Exceptions
namespace  FITS
namespace  gl
namespace  Harris
namespace  ImageError
namespace  ImageType
namespace  ImageUtil
namespace  Internal
namespace  Interpolate
namespace  JPEG
namespace  median
namespace  Morphology
namespace  Pixel
namespace  PNG
namespace  PNM
namespace  PS
namespace  QT
 

Internal QT helpers.


namespace  SGI
 

Internal O2Buffer helpers.


namespace  TensorVoting
namespace  TEXT
namespace  TIFF
namespace  V4L
namespace  V4L1
 

Internal V4L1 helpers.


namespace  VFB
 

Internal VideoFileBuffer helpers.


namespace  VideoBufferFlags
 

Flags common to several different VideoBuffer classes.


namespace  VideoFrameFlags

Classes

struct  AlignedMem
class  Argb
class  BasicImage
struct  bayer_bggr
struct  bayer_bggr16
struct  bayer_bggr16be
struct  bayer_gbrg
struct  bayer_gbrg16
struct  bayer_gbrg16be
struct  bayer_grbg
struct  bayer_grbg16
struct  bayer_grbg16be
struct  bayer_rggb
struct  bayer_rggb16
struct  bayer_rggb16be
class  Bgrx
class  Brezenham
class  Brezenham8
struct  CastCopy
struct  CastCopy< T, T >
struct  color
struct  color< T, 1 >
struct  color< T, 3 >
class  ColourspaceBuffer
class  ColourspaceBuffer_managed
 This is just like ColourspaceBuffer, except it deleted the videobuffer on destruction. More...
class  ColourspaceFrame
 A frame from a ColourspaceBuffer. Can be treated as a VideoFrame. More...
class  ConstSubImageIterator
struct  ConvertImage
struct  ConvertImage< Rgb< byte >, byte, Pixel::CIE< Rgb< byte >, byte >, 1 >
struct  ConvertImage< T, T, Pixel::GenericConversion< T, T >, 1 >
struct  ConvolveMiddle
struct  ConvolveMiddle< T, 0, 1 >
struct  ConvolveMiddle< T, N, 1 >
struct  ConvolveMiddle< T,-1, 1 >
struct  ConvolveMiddle< T,-1, C >
class  cvd_timer
class  DeinterlaceBuffer
class  DeinterlaceFrame
class  DiskBuffer2
class  DiskBuffer2Frame
class  DVBuffer2
class  DVBuffer3
class  DVFrame
class  EventObject
 Encapsulation of a condition variable and its boolean condition. More...
struct  GetPixelRowTyped
struct  GetPixelRowTyped< T, T >
class  GLWindow
 An object that creates a window and a GL context attached to that window, and manages its events. More...
struct  Gradient< S, T, 1, 2 >
struct  ILinear
class  Image
class  image_interpolate< Interpolate::Bicubic, T >
class  image_interpolate< Interpolate::Bilinear, T >
class  image_interpolate< Interpolate::NearestNeighbour, C >
class  ImageCreationIterator
class  ImageRef
class  IRLS
struct  IsConvertible
struct  IsConvertible< bayer_bggr, byte >
struct  IsConvertible< bayer_bggr, Rgb< byte > >
struct  IsConvertible< bayer_bggr16, Rgb< unsigned short > >
struct  IsConvertible< bayer_bggr16, unsigned short >
struct  IsConvertible< bayer_bggr16be, Rgb< unsigned short > >
struct  IsConvertible< bayer_bggr16be, unsigned short >
struct  IsConvertible< bayer_gbrg, byte >
struct  IsConvertible< bayer_gbrg, Rgb< byte > >
struct  IsConvertible< bayer_gbrg16, Rgb< unsigned short > >
struct  IsConvertible< bayer_gbrg16, unsigned short >
struct  IsConvertible< bayer_gbrg16be, Rgb< unsigned short > >
struct  IsConvertible< bayer_gbrg16be, unsigned short >
struct  IsConvertible< bayer_grbg, byte >
struct  IsConvertible< bayer_grbg, Rgb< byte > >
struct  IsConvertible< bayer_grbg16, Rgb< unsigned short > >
struct  IsConvertible< bayer_grbg16, unsigned short >
struct  IsConvertible< bayer_grbg16be, Rgb< unsigned short > >
struct  IsConvertible< bayer_grbg16be, unsigned short >
struct  IsConvertible< bayer_rggb, byte >
struct  IsConvertible< bayer_rggb, Rgb< byte > >
struct  IsConvertible< bayer_rggb16, Rgb< unsigned short > >
struct  IsConvertible< bayer_rggb16, unsigned short >
struct  IsConvertible< bayer_rggb16be, Rgb< unsigned short > >
struct  IsConvertible< bayer_rggb16be, unsigned short >
struct  IsConvertible< yuv411, byte >
struct  IsConvertible< yuv411, Rgb< byte > >
struct  IsConvertible< yuv422, byte >
struct  IsConvertible< yuv422, Rgb< byte > >
class  La
struct  La_ops
class  LocalVideoBuffer
class  LocalVideoFrame
struct  Lock
struct  MakeConverter
struct  MakeConverter< Out, In, false >
struct  MakeConverter< T, T, true >
struct  makeDiskBuffer2
struct  makeDiskBuffer2< T, false >
struct  makeJPEGStream
struct  makeJPEGStream< T, false >
class  MessageQueue
 This class provides a simple, thread safe FIFO message queue. More...
struct  multiplyBy
class  O2Buffer
class  O2VideoFrame
class  Parameter
class  Parameter< Internal::UntypedParameter >
class  Parameter< void >
struct  ParseException
struct  PixelByPixelConvertible
struct  PixelByPixelConvertible< InOut, InOut >
 Identity conversion by memcpy is always supported. More...
class  QTBuffer
class  QTFrame
class  RawVideoBuffer
class  ReadAheadVideoBuffer
class  Rgb
struct  Rgb8
struct  Rgb_ops
class  Rgba
struct  Rgba_ops
class  RingBuffer
struct  RobustI
struct  RobustII
class  Runnable
 This is an abstract base class for anything with a run() method. More...
class  RunnableBatch
class  ServerPushJpegBuffer
class  ServerPushJpegFrame
class  SimpleTimer
class  SubImage
class  SubImageIterator
struct  SumSquaredDifferences
class  Synchronized
class  Thread
class  TimedDiskBuffer
class  V4L1Buffer
class  V4L1Frame
struct  V4L2_Traits< CVD::YC >
struct  V4L2_Traits< unsigned char >
class  V4L2Buffer_Base
class  V4L2BufferT
class  V4L2FrameT
class  V4LBuffer
class  V4LControl
class  VideoBuffer
struct  VideoBufferType
 The semsntics of the videobuffer. See VideoFrame::type(). More...
class  VideoBufferWithData
class  VideoDisplay
class  VideoFileBuffer
class  VideoFileFrame
class  VideoFrame
struct  VideoSource
struct  VideoSourceException
struct  vuy422
struct  YC
struct  yuv411
struct  yuv420p
struct  yuv422
struct  ZeroPixel
struct  ZeroPixel< T, true >
struct  ZeroPixels
struct  ZeroPixels< T, true >

Typedefs

typedef bayer_bggr bayer
typedef Brezenham Bresenham
typedef Brezenham8 Bresenham8
typedef unsigned char byte
typedef DVBuffer2< byte > DVBuffer
typedef V4L1Buffer< byte > V4L1BufferByte
typedef V4L2BufferT< unsigned
char > 		V4L2Buffer
 Nontemplated V4L2Buffer type for backwards compatibility.
typedef V4L2FrameT< unsigned char > V4L2Frame
 Nontemplated video frame type for backwards compatibility.

Enumerations

enum  TEXT_STYLE { FILL = 0, OUTLINE = 1, NICE = 2 }
 

different style for font rendering

More...
enum  V4L2BufferBlockMethod { V4L2BBMselect, V4L2BBMsleep, V4L2BBMchew }
 

Which buffer block method shall I use?

More...

Functions

unsigned long abs (unsigned long u)
unsigned int abs (unsigned int u)
unsigned short abs (unsigned short u)
unsigned char abs (unsigned char b)
template<class T >
T abs (T t)
void add_multiple_of_sum (const double *a, const double *b, const double &c, double *out, size_t count)
void add_multiple_of_sum (const float *a, const float *b, const float &c, float *out, size_t count)
template<class A , class B , class C >
void add_multiple_of_sum (const A *a, const A *b, const C &c, B *out, size_t count)
void assign_multiple (const double *a, const double &c, double *out, size_t count)
void assign_multiple (const float *a, const float &c, float *out, size_t count)
template<class A , class B , class C >
void assign_multiple (const A *a, const B &c, C *out, size_t count)
template<class T , class S >
void cast_copy (const T *from, S *to, int count)
template<class S , class T , class U >
void combineImages (const Image< S > &a, const Image< T > &b, Image< U > &out, const ImageRef &dst=ImageRef_zero, ImageRef size=ImageRef(), const ImageRef &from=ImageRef_zero)
void compute_triggs_M (const double b[], double M[][3])
void compute_van_vliet_b (double sigma, double b[])
void connected_components (const std::vector< ImageRef > &v, std::vector< std::vector< ImageRef > > &r)
template<class C >
Internal::ImagePromise
< Internal::ImageConverter< C > > 		convert_image (const BasicImage< C > &c)
template<class D , class C >
Image< D > convert_image (const BasicImage< C > &from)
template<class D , class C >
Image< D > convert_image (const SubImage< C > &from)
template<class D , class Conv , class C >
Image< D > convert_image (const SubImage< C > &from)
template<class C , class D >
void convert_image (const BasicImage< C > &from, BasicImage< D > &to)
template<class C , class D >
void convert_image (const SubImage< C > &from, SubImage< D > &to)
template<class Conv , class C , class D >
void convert_image (const SubImage< C > &from, SubImage< D > &to)
template<>
void convert_image (const BasicImage< vuy422 > &from, BasicImage< byte > &to)
template<>
void convert_image (const BasicImage< vuy422 > &from, BasicImage< Rgb< byte > > &to)
template<>
void convert_image (const BasicImage< yuv422 > &from, BasicImage< byte > &to)
template<>
void convert_image (const BasicImage< yuv422 > &from, BasicImage< Rgb< byte > > &to)
template<>
void convert_image (const BasicImage< yuv411 > &from, BasicImage< byte > &to)
template<>
void convert_image (const BasicImage< yuv411 > &from, BasicImage< Rgb< byte > > &to)
template<>
void convert_image (const BasicImage< bayer_rggb16be > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_gbrg16be > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_grbg16be > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_bggr16be > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_rggb16be > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_gbrg16be > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_grbg16be > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_bggr16be > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_rggb16 > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_gbrg16 > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_grbg16 > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_bggr16 > &from, BasicImage< Rgb< unsigned short > > &to)
template<>
void convert_image (const BasicImage< bayer_rggb16 > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_gbrg16 > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_grbg16 > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_bggr16 > &from, BasicImage< unsigned short > &to)
template<>
void convert_image (const BasicImage< bayer_rggb > &from, BasicImage< Rgb< byte > > &to)
template<>
void convert_image (const BasicImage< bayer_gbrg > &from, BasicImage< Rgb< byte > > &to)
template<>
void convert_image (const BasicImage< bayer_grbg > &from, BasicImage< Rgb< byte > > &to)
template<>
void convert_image (const BasicImage< bayer_bggr > &from, BasicImage< Rgb< byte > > &to)
template<>
void convert_image (const BasicImage< bayer_rggb > &from, BasicImage< byte > &to)
template<>
void convert_image (const BasicImage< bayer_gbrg > &from, BasicImage< byte > &to)
template<>
void convert_image (const BasicImage< bayer_grbg > &from, BasicImage< byte > &to)
template<>
void convert_image (const BasicImage< bayer_bggr > &from, BasicImage< byte > &to)
template<class D1 , class D2 , class C >
std::pair< Image< D1 >, Image
< D2 > > 		convert_image_pair (const BasicImage< C > &from)
template<>
std::pair< Image< byte >
, Image< Rgb< byte > > > 		convert_image_pair (const BasicImage< yuv411 > &from)
template<class T , class O , class K >
void convolve_gaussian_3 (const BasicImage< T > &I, BasicImage< O > &out, K k1, K k2)
void convolveGaussian (const BasicImage< float > &I, BasicImage< float > &out, double sigma, double sigmas=3.0)
template<class T >
void convolveGaussian (const BasicImage< T > &I, BasicImage< T > &out, double sigma, double sigmas=3.0)
template<class T >
void convolveGaussian (BasicImage< T > &I, double sigma, double sigmas=3.0)
template<class T >
void convolveGaussian5_1 (BasicImage< T > &I)
void convolveGaussian_fir (const BasicImage< float > &I, BasicImage< float > &out, double sigma, double sigmas=3.0)
template<class T , class S >
const T * convolveMiddle (const T *input, const S &factor, const S *kernel, int ksize, int n, T *output)
template<class T , class K >
void convolveSeparableSymmetric (Image< T > &I, const std::vector< K > &kernel, K divisor)
template<class T , int A, int B, int C, int D>
void convolveSymmetric (Image< T > &I)
template<class T , int A, int B, int C>
void convolveSymmetric (Image< T > &I)
template<class T >
void convolveWithBox (BasicImage< T > &I, ImageRef hwin)
template<class T >
void convolveWithBox (BasicImage< T > &I, int hwin)
template<class T >
void convolveWithBox (const BasicImage< T > &I, BasicImage< T > &J, int hwin)
template<class T >
void convolveWithBox (const BasicImage< T > &I, BasicImage< T > &J, ImageRef hwin)
template<class S , class T >
void copy (const BasicImage< S > &in, BasicImage< T > &out, ImageRef size=ImageRef(-1,-1), ImageRef begin=ImageRef(), ImageRef dst=ImageRef())
template<class C >
ImageCreationIterator< C > CreateImagesBegin (const C &from_me)
template<class C >
ImageCreationIterator< C > CreateImagesEnd (int i)
template<class C >
ImageCreationIterator< C > CreateImagesEnd (const C &, int i)
template<class C >
Image< TooN::Matrix< 2 > > dense_tensor_vote_gradients (const SubImage< C > &image, double sigma, double ratio, double cutoff=0.001, unsigned int num_divs=4096)
void differences (const double *a, const double *b, double *diff, size_t size)
void differences (const int32_t *a, const int32_t *b, int32_t *diff, size_t size)
void differences (const float *a, const float *b, float *diff, size_t size)
void differences (const short *a, const short *b, short *diff, unsigned int size)
void differences (const byte *a, const byte *b, short *diff, unsigned int size)
template<class A , class B >
void differences (const A *a, const A *b, B *diff, size_t count)
template<class T >
void drawBox (SubImage< T > &im, const ImageRef &upperleft, const ImageRef &lowerright, const T &c)
template<class T >
void drawCross (SubImage< T > &im, const ImageRef &p, double len, const T &c)
template<class T >
void drawLine (SubImage< T > &im, const ImageRef &p1, const ImageRef &p2, const T &c)
template<class T >
void drawLine (SubImage< T > &im, double x1, double y1, double x2, double y2, const T &c)
template<class T >
void drawShape (SubImage< T > &im, const ImageRef &offset, const std::vector< ImageRef > &points, const T &c)
void enableFPE ()
void fast_corner_detect_10 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void fast_corner_detect_11 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void fast_corner_detect_12 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void fast_corner_detect_7 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void fast_corner_detect_8 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void fast_corner_detect_9 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier)
void fast_corner_detect_9_nonmax (const BasicImage< byte > &im, std::vector< ImageRef > &max_corners, int barrier)
void fast_corner_score_10 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void fast_corner_score_11 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void fast_corner_score_12 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void fast_corner_score_7 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void fast_corner_score_8 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void fast_corner_score_9 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores)
void fast_nonmax (const BasicImage< byte > &im, const std::vector< ImageRef > &corners, int barrier, std::vector< ImageRef > &max_corners)
void fast_nonmax_with_scores (const BasicImage< byte > &im, const std::vector< ImageRef > &corners, int barrier, std::vector< std::pair< ImageRef, int > > &max_corners)
template<class T >
void fillBorders (SubImage< T > &im, const T pix, int w=1)
template<class T >
void flipHorizontal (Image< T > &in)
 flips an image horizontally in place.
template<class T >
void flipVertical (Image< T > &in)
 flips an image vertically in place.
template<class T >
T gaussianKernel (std::vector< T > &k, T maxval, double stddev)
void get_colourspace_options (const VideoSource &vs, std::string &from)
void get_dc1394_options (const VideoSource &vs, ImageRef &size, float &fps, ImageRef &offset, bool &verbose, bool &bus_reset, int &format7_mode)
void get_file_options (const VideoSource &vs, int &ra_frames, VideoBufferFlags::OnEndOfBuffer &eob)
void get_files_options (const VideoSource &vs, int &fps, int &ra_frames, VideoBufferFlags::OnEndOfBuffer &eob)
void get_jpegstream_options (const VideoSource &vs, int &fps)
void get_qt_options (const VideoSource &vs, ImageRef &size, bool &showsettings, bool &verbose)
double get_time_of_day ()
void get_v4l1_options (const VideoSource &vs, ImageRef &size)
void get_v4l2_options (const VideoSource &vs, ImageRef &size, int &input, bool &interlaced, bool &verbose)
std::vector< ImageRef > getCircle (int radius)
std::vector< ImageRef > getDisc (float radius)
template<class A , class B >
const B * getPixelRowTyped (const A *row, int n, B *rowbuf)
void glColor (const CVD::Rgba< float > &c)
void glColor (const CVD::Rgba< unsigned char > &c)
void glColor (const CVD::Rgb< float > &c)
void glColor (const CVD::Rgb< byte > &c)
void glColor3 (const CVD::Rgb8 &c)
void glColor4 (const CVD::Rgb8 &c)
template<class C >
void glDrawPixels (const SubImage< C > &i)
std::pair< double, double > glDrawText (const std::string &text, enum TEXT_STYLE style=NICE, double spacing=1.5, double kerning=0.1)
std::pair< double, double > glGetExtends (const std::string &text, double spacing=1.5, double kerning=0.1)
 returns the size of the bounding box of a text to be rendered, similar to glDrawText but without any visual output
const std::string & glGetFont ()
 returns the name of the currently active font
template<class P1 , class P2 >
void glLine (const P1 &x1, const P2 &x2)
std::vector< std::string > globlist (const std::string &gl)
void glPrintErrors (void)
void glRasterPos (const ImageRef &i)
template<class C >
Image< C > glReadPixels (ImageRef size, ImageRef origin=ImageRef(0, 0))
template<class C >
void glReadPixels (BasicImage< C > &i, ImageRef origin=ImageRef(0, 0))
void glRect (const ImageRef &p, const ImageRef &q)
void glSetFont (const std::string &fontname)
void glTexCoord (const ImageRef &i)
template<class C >
void glTexImage2D (const SubImage< C > &i, GLint border=0, GLenum target=GL_TEXTURE_2D, GLint level=0)
template<class C >
void glTexSubImage2D (const SubImage< C > &i, GLint xoffset=0, GLint yoffset=0, GLenum target=GL_TEXTURE_2D, GLint level=0)
template<class C >
void glVertex (const C &list)
void glVertex (const ImageRef &i)
void gradient (const BasicImage< byte > &im, BasicImage< short[2]> &out)
template<class S , class T >
void gradient (const BasicImage< S > &im, BasicImage< T > &out)
template<class It >
void haar1D (It from, int size)
template<class It >
void haar1D (It from, It to)
template<class T >
void haar2D (SubImage< T > &I)
template<class It >
void haar2D (It from, const int width, const int height, int stride=-1)
template<class T >
Image< T > halfSample (Image< T > in, unsigned int octaves)
template<class T >
Image< T > halfSample (const BasicImage< T > &in)
void halfSample (const BasicImage< byte > &in, BasicImage< byte > &out)
template<class T >
void halfSample (const BasicImage< T > &in, BasicImage< T > &out)
template<class C >
void harris_corner_detect (const SubImage< C > &i, std::vector< ImageRef > &c, unsigned int N, float blur=1.0, float sigmas=3.0)
template<class Score , class Inserter , class C , class B >
void harrislike_corner_detect (const SubImage< B > &i, C &c, unsigned int N, float blur, float sigmas, BasicImage< float > &xx, BasicImage< float > &xy, BasicImage< float > &yy)
template<class I >
void img_load (Image< I > &im, const std::string &s)
template<class I >
void img_load (Image< I > &im, std::istream &i)
Internal::ImagePromise
< Internal::ImageLoaderString > 		img_load (const std::string &s)
Internal::ImagePromise
< Internal::ImageLoaderIstream > 		img_load (std::istream &i)
template<class PixelType >
void img_save (const BasicImage< PixelType > &im, const std::string &name, const std::map< std::string, Parameter<> > &p=std::map< std::string, Parameter<> >())
template<class PixelType >
void img_save (const BasicImage< PixelType > &im, const std::string &name, ImageType::ImageType t, ImageType::ImageType d=ImageType::PNM, const std::map< std::string, Parameter<> > &p=std::map< std::string, Parameter<> >())
template<class PixelType >
void img_save (const BasicImage< PixelType > &im, std::ostream &o, ImageType::ImageType t, const std::map< std::string, Parameter<> > &p=std::map< std::string, Parameter<> >())
double inner_product (const double *a, const double *b, size_t count)
double inner_product (const float *a, const float *b, size_t count)
template<class T >
double inner_product (const T *a, const T *b, size_t count)
template<class C >
Internal::ImagePromise
< Internal::IntegralImage< C > > 		integral_image (const SubImage< C > &c)
template<class S , class D >
void integral_image (const SubImage< S > &in, SubImage< D > &out)
double interpolate_extremum (double d1, double d2, double d3)
template<class I >
std::pair< TooN::Vector
< 2 >, double > 		interpolate_extremum_value (const SubImage< I > &i, ImageRef p)
std::pair< TooN::Vector
< 2 >, double > 		interpolate_extremum_value (double I__1__1, double I__1_0, double I__1_1, double I_0__1, double I_0_0, double I_0_1, double I_1__1, double I_1_0, double I_1_1)
template<class It >
void inv_haar1D (It from, int size)
template<class It >
void inv_haar1D (It from, It to)
ImageRef ir (const TooN::Vector< 2 > &v)
ImageRef ir_rounded (const TooN::Vector< 2 > &v)
template<int bytes>
bool is_aligned (const void *ptr)
 Check if the pointer is aligned to the specified byte granularity.
template<>
bool is_aligned< 16 > (const void *ptr)
template<>
bool is_aligned< 8 > (const void *ptr)
template<class S , class T , class U >
void joinImages (const Image< S > &a, const Image< T > &b, Image< U > &J)
template<class T >
VideoBuffer< T > * makeColourspaceBuffer (const std::string &c, const std::string &r)
template<class Out , class In >
VideoBuffer< Out > * makeConvertBufferBit (const std::string &r)
template<>
VideoBuffer< byte > * makeDVBuffer2 (int cam, ImageRef size, float fps, ImageRef offset, bool verbose, bool bus_reset, int format7_mode)
template<class T >
VideoBuffer< T > * makeDVBuffer2 (int, ImageRef, float, ImageRef, bool, bool, int)
template<>
VideoBuffer< vuy422 > * makeQTBuffer (const ImageRef &size, int input, bool showsettings, bool verbose)
template<class T >
VideoBuffer< T > * makeQTBuffer (const ImageRef &, int, bool, bool)
template<>
VideoBuffer< byte > * makeV4L1Buffer (const std::string &dev, const ImageRef &size)
template<class T >
VideoBuffer< T > * makeV4L1Buffer (const std::string &, const ImageRef &)
template<>
VideoBuffer< byte > * makeV4LBuffer (const std::string &dev, const ImageRef &size, int input, bool interlaced, bool verbose)
template<class T >
VideoBuffer< T > * makeV4LBuffer (const std::string &, const ImageRef &, int, bool, bool)
template<>
VideoBuffer< byte > * makeVideoFileBuffer (const std::string &file, VideoBufferFlags::OnEndOfBuffer eob)
template<class T >
VideoBuffer< T > * makeVideoFileBuffer (const std::string &, VideoBufferFlags::OnEndOfBuffer)
void median_filter_3x3 (const SubImage< byte > &I, SubImage< byte > out)
template<class T >
void median_filter_3x3 (const SubImage< T > &I, SubImage< T > out)
void morphology (const SubImage< byte > &in, const std::vector< ImageRef > &selem, const Morphology::Median< byte > &m, SubImage< byte > &out)
template<class C , class D >
Internal::ImagePromise
< Internal::PerformMorphology
< C, D > > 		morphology (const SubImage< C > &c, const std::vector< ImageRef > &selem, const D &a)
template<class Accumulator , class T >
void morphology (const SubImage< T > &in, const std::vector< ImageRef > &selem, const Accumulator &a_, SubImage< T > &out)
void nonmax_suppression (const std::vector< ImageRef > &corners, const std::vector< int > &scores, std::vector< ImageRef > &nmax_corners)
void nonmax_suppression_strict (const std::vector< ImageRef > &corners, const std::vector< int > &scores, std::vector< ImageRef > &nmax_corners)
void nonmax_suppression_with_scores (const std::vector< ImageRef > &corners, const std::vector< int > &socres, std::vector< std::pair< ImageRef, int > > &max_corners)
template<class T >
VideoBuffer< T > * open_video_source (std::istream &in)
template<class T >
VideoBuffer< T > * open_video_source (const VideoSource &vs)
template<class T >
VideoBuffer< T > * open_video_source (const std::string &src)
template<class T , class S >
La< T > operator* (const S &b, const La< T > &a)
template<class T , class S >
La< T > operator* (const La< T > &a, const S &b)
template<class T , class S >
Rgba< T > operator* (const S &b, const Rgba< T > &a)
template<class T , class S >
Rgba< T > operator* (const Rgba< T > &a, const S &b)
template<class T , class S >
Rgb< T > operator* (const S &b, const Rgb< T > &a)
template<class T , class S >
Rgb< T > operator* (const Rgb< T > &a, const S &b)
ImageRef operator* (const int scale, const ImageRef &ref)
template<class T , class S >
La< T > & operator*= (La< T > &a, const S &b)
template<class T , class S >
Rgba< T > & operator*= (Rgba< T > &a, const S &b)
template<class T , class S >
Rgb< T > & operator*= (Rgb< T > &a, const S &b)
template<class T , class S >
La< T > operator+ (const La< T > &a, const La< S > &b)
template<class T , class S >
Rgba< T > operator+ (const Rgba< T > &a, const Rgba< S > &b)
template<class T , class S >
Rgb< T > operator+ (const Rgb< T > &a, const Rgb< S > &b)
template<class T , class S >
La< T > & operator+= (La< T > &a, const La< S > &b)
template<class T , class S >
Rgba< T > & operator+= (Rgba< T > &a, const Rgba< S > &b)
template<class T , class S >
Rgb< T > & operator+= (Rgb< T > &a, const Rgb< S > &b)
template<class T , class S >
La< T > operator- (const La< T > &a, const La< S > &b)
template<class T , class S >
Rgba< T > operator- (const Rgba< T > &a, const Rgba< S > &b)
template<class T , class S >
Rgb< T > operator- (const Rgb< T > &a, const Rgb< S > &b)
template<class T , class S >
La< T > & operator-= (La< T > &a, const La< S > &b)
template<class T , class S >
Rgba< T > & operator-= (Rgba< T > &a, const Rgba< S > &b)
template<class T , class S >
Rgb< T > & operator-= (Rgb< T > &a, const Rgb< S > &b)
template<class T , class S >
La< T > operator/ (const S &b, const La< T > &a)
template<class T , class S >
La< T > operator/ (const La< T > &a, const S &b)
template<class T , class S >
Rgba< T > operator/ (const S &b, const Rgba< T > &a)
template<class T , class S >
Rgba< T > operator/ (const Rgba< T > &a, const S &b)
template<class T , class S >
Rgb< T > operator/ (const S &b, const Rgb< T > &a)
template<class T , class S >
Rgb< T > operator/ (const Rgb< T > &a, const S &b)
template<class T , class S >
La< T > & operator/= (La< T > &a, const S &b)
template<class T , class S >
Rgba< T > & operator/= (Rgba< T > &a, const S &b)
template<class T , class S >
Rgb< T > & operator/= (Rgb< T > &a, const S &b)
std::ostream & operator<< (std::ostream &out, const VideoSource &vs)
void output_eps_footer (std::ostream &o)
template<class PixelType >
void output_eps_header (std::ostream &o, const BasicImage< PixelType > &im)
void output_eps_header (std::ostream &o, const ImageRef &s)
void output_eps_header (std::ostream &o, int xs, int ys)
void parse (std::istream &in, VideoSource &vs)
template<class PixelType >
void pnm_load (Image< PixelType > &im, std::istream &i)
template<class PixelType >
void pnm_save (const BasicImage< PixelType > &im, std::ostream &o)
template<int I>
void prefetch (const void *ptr)
double rand_g ()
double rand_u ()
void sample (const BasicImage< float > &im, double x, double y, float &result)
template<class T , class S >
T sample (const BasicImage< S > &im, double x, double y)
template<class T , class S >
void sample (const BasicImage< S > &im, double x, double y, T &result)
template<class S , class T >
T scaleKernel (const std::vector< S > &k, std::vector< T > &scaled, T maxval)
template<class C >
void shitomasi_corner_detect (const SubImage< C > &i, std::vector< ImageRef > &c, unsigned int N, float blur=1.0, float sigmas=3.0)
void square (const float *in, float *out, size_t count)
template<class T1 , class T2 >
void square (const T1 *in, T2 *out, size_t count)
template<class T >
void stats (const BasicImage< T > &im, T &mean, T &stddev)
template<int A, class T >
size_t steps_to_align (const T *ptr)
 Compute the number of pointer increments necessary to yield alignment of A bytes.
ImageType::ImageType string_to_image_type (const std::string &name)
void subtract_square (const float *in, float *out, size_t count)
template<class T1 , class T2 >
void subtract_square (const T1 *in, T2 *out, size_t count)
long long sum_squared_differences (const byte *a, const byte *b, size_t count)
double sum_squared_differences (const double *a, const double *b, size_t count)
double sum_squared_differences (const float *a, const float *b, size_t count)
template<class T >
double sum_squared_differences (const T *a, const T *b, size_t count)
template<class T >
void threshold (BasicImage< T > &im, const T &minimum, const T &hi)
template<class C >
Internal::ImagePromise
< Internal::twoThirdsSampler
< C > > 		twoThirdsSample (const SubImage< C > &c)
void twoThirdsSample (const SubImage< byte > &in, SubImage< byte > &out)
template<class C >
void twoThirdsSample (const SubImage< C > &in, SubImage< C > &out)
void van_vliet_blur (const double b[], const SubImage< float > in, SubImage< float > out)
TooN::Vector< 2 > vec (const ImageRef &ir)
template<class T >
void zeroBorders (BasicImage< T > &I)
 Set the one-pixel border (top, bottom, sides) of an image to zero values.
template<class T >
void zeroPixel (T &pixel)
template<class T >
void zeroPixels (T *pixels, int count)

Variables

const ImageRef fast_pixel_ring [16]
cvd_timer timer

Detailed Description

All classes and functions are within the CVD namespace

Typedef Documentation

typedef V4L2BufferT<unsigned char> CVD::V4L2Buffer

Nontemplated V4L2Buffer type for backwards compatibility.

Definition at line 170 of file v4l2buffer.h.

typedef V4L2FrameT<unsigned char> CVD::V4L2Frame

Nontemplated video frame type for backwards compatibility.

Definition at line 80 of file v4l2frame.h.

Enumeration Type Documentation

enum CVD::V4L2BufferBlockMethod

Which buffer block method shall I use?

Enumerator:
V4L2BBMselect 
V4L2BBMsleep 
V4L2BBMchew 

Definition at line 37 of file v4l2buffer.h.

Function Documentation

void CVD::add_multiple_of_sum ( const double *  a,
const double *  b,
const double &  c,
double *  out,
size_t  count 
)
void CVD::add_multiple_of_sum ( const float *  a,
const float *  b,
const float &  c,
float *  out,
size_t  count 
)
template<class A , class B , class C >
void CVD::add_multiple_of_sum ( const A *  a,
const A *  b,
const C &  c,
B *  out,
size_t  count 
) [inline]

Compute pointwise (a_i + b_i) * c and add to out_i This is accelerated using SIMD for some platforms and data types (alignment is checked at runtime) Do not specify template parameters explicitly so that overloading can choose the right implementation

Definition at line 138 of file utility.h.

void CVD::assign_multiple ( const double *  a,
const double &  c,
double *  out,
size_t  count 
)
void CVD::assign_multiple ( const float *  a,
const float &  c,
float *  out,
size_t  count 
)
template<class A , class B , class C >
void CVD::assign_multiple ( const A *  a,
const B &  c,
C *  out,
size_t  count 
) [inline]

Compute pointwise a_i * c and store in out_i This is accelerated using SIMD for some platforms and data types (alignment is checked at runtime) Do not specify template parameters explicitly so that overloading can choose the right implementation

Definition at line 147 of file utility.h.

template<class T , class S >
void CVD::cast_copy ( const T *  from,
S *  to,
int  count 
) [inline]

Definition at line 363 of file convolution.h.

void CVD::compute_triggs_M ( const double  b[],
double  M[][3] 
)
void CVD::compute_van_vliet_b ( double  sigma,
double  b[] 
)
template<class C >
Internal::ImagePromise<Internal::ImageConverter<C> > CVD::convert_image ( const BasicImage< C > &  c  )  [inline]

Definition at line 160 of file image_convert.h.

template<class D , class C >
Image<D> CVD::convert_image ( const SubImage< C > &  from  )  [inline]

Convert an image from one type to another using the default.

Parameters:
D The destination image pixel type
C The source image pixel type
from The image to convert from

Definition at line 105 of file image_convert.h.

template<class C , class D >
void CVD::convert_image ( const BasicImage< C > &  from,
BasicImage< D > &  to 
) [inline]

Definition at line 73 of file image_convert.h.

template<class C , class D >
void CVD::convert_image ( const SubImage< C > &  from,
SubImage< D > &  to 
) [inline]

Definition at line 66 of file image_convert.h.

template<class Conv , class C , class D >
void CVD::convert_image ( const SubImage< C > &  from,
SubImage< D > &  to 
) [inline]

Definition at line 59 of file image_convert.h.

template<>
void CVD::convert_image ( const BasicImage< bayer_rggb16be > &  from,
BasicImage< Rgb< unsigned short > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_gbrg16be > &  from,
BasicImage< Rgb< unsigned short > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_grbg16be > &  from,
BasicImage< Rgb< unsigned short > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_rggb16be > &  from,
BasicImage< unsigned short > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_gbrg16be > &  from,
BasicImage< unsigned short > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_grbg16be > &  from,
BasicImage< unsigned short > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_rggb16 > &  from,
BasicImage< Rgb< unsigned short > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_gbrg16 > &  from,
BasicImage< Rgb< unsigned short > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_grbg16 > &  from,
BasicImage< Rgb< unsigned short > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_rggb16 > &  from,
BasicImage< unsigned short > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_gbrg16 > &  from,
BasicImage< unsigned short > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_grbg16 > &  from,
BasicImage< unsigned short > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_rggb > &  from,
BasicImage< Rgb< byte > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_gbrg > &  from,
BasicImage< Rgb< byte > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_grbg > &  from,
BasicImage< Rgb< byte > > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_rggb > &  from,
BasicImage< byte > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_gbrg > &  from,
BasicImage< byte > &  to 
) [inline]
template<>
void CVD::convert_image ( const BasicImage< bayer_grbg > &  from,
BasicImage< byte > &  to 
) [inline]
template<class T , class O , class K >
void CVD::convolve_gaussian_3 ( const BasicImage< T > &  I,
BasicImage< O > &  out,
K  k1,
K  k2 
) [inline]

Definition at line 527 of file convolution.h.

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 
) [inline]

Definition at line 420 of file convolution.h.

template<class T >
void CVD::convolveGaussian ( BasicImage< T > &  I,
double  sigma,
double  sigmas = 3.0 
) [inline]

Definition at line 415 of file convolution.h.

template<class T >
void CVD::convolveGaussian5_1 ( BasicImage< T > &  I  )  [inline]

Definition at line 86 of file convolution.h.

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 
) [inline]

Definition at line 395 of file convolution.h.

template<class T , class K >
void CVD::convolveSeparableSymmetric ( Image< T > &  I,
const std::vector< K > &  kernel,
K  divisor 
) [inline]

Definition at line 302 of file convolution.h.

template<class T , int A, int B, int C, int D>
void CVD::convolveSymmetric ( Image< T > &  I  )  [inline]

Definition at line 251 of file convolution.h.

template<class T , int A, int B, int C>
void CVD::convolveSymmetric ( Image< T > &  I  )  [inline]

Definition at line 209 of file convolution.h.

template<class T >
void CVD::convolveWithBox ( BasicImage< T > &  I,
ImageRef  hwin 
) [inline]

Definition at line 204 of file convolution.h.

template<class T >
void CVD::convolveWithBox ( BasicImage< T > &  I,
int  hwin 
) [inline]

Definition at line 200 of file convolution.h.

template<class T >
void CVD::convolveWithBox ( const BasicImage< T > &  I,
BasicImage< T > &  J,
int  hwin 
) [inline]

Definition at line 195 of file convolution.h.

template<class C >
ImageCreationIterator<C> CVD::CreateImagesBegin ( const C &  from_me  )  [inline]

Shortcut function for creating an iterator from a bit of data..

Parameters:
from_me Data to construct from

Definition at line 584 of file image.h.

template<class C >
ImageCreationIterator<C> CVD::CreateImagesEnd ( int  i  )  [inline]

Shortcut to create an end iterator.

Parameters:
i Number of copies to make

Definition at line 598 of file image.h.

template<class C >
ImageCreationIterator<C> CVD::CreateImagesEnd ( const C &  ,
int  i 
) [inline]

Shortcut to create an end iterator. The first parameter is used to get the type correct.

Parameters:
i Number of copies to make

Definition at line 591 of file image.h.

void CVD::differences ( const double *  a,
const double *  b,
double *  diff,
size_t  size 
)
void CVD::differences ( const int32_t *  a,
const int32_t *  b,
int32_t *  diff,
size_t  size 
)
void CVD::differences ( const float *  a,
const float *  b,
float *  diff,
size_t  size 
)
void CVD::differences ( const short *  a,
const short *  b,
short *  diff,
unsigned int  size 
)
void CVD::differences ( const byte *  a,
const byte *  b,
short *  diff,
unsigned int  size 
)
template<class A , class B >
void CVD::differences ( const A *  a,
const A *  b,
B *  diff,
size_t  count 
) [inline]

Compute pointwise differences (a_i - b_i) and store in diff_i This is accelerated using SIMD for some platforms and data types (alignment is checked at runtime) Do not specify template parameters explicitly so that overloading can choose the right implementation

Definition at line 129 of file utility.h.

void CVD::enableFPE (  )  [inline]

Enable floating point exceptions. This function may do nothing, depending on the architecture

Definition at line 53 of file cpu_hacks.h.

template<class T >
void CVD::fillBorders ( SubImage< T > &  im,
const T  pix,
int  w = 1 
) [inline]

Fill image borders

Parameters:
im Image fo fill borders in
pix Fill value
w border width

Definition at line 104 of file utility.h.

template<class T >
void CVD::flipHorizontal ( Image< T > &  in  )  [inline]

flips an image horizontally in place.

Definition at line 440 of file vision.h.

template<class T >
void CVD::flipVertical ( Image< T > &  in  )  [inline]

flips an image vertically in place.

Definition at line 422 of file vision.h.

void CVD::get_colourspace_options ( const VideoSource &  vs,
std::string &  from 
)
void CVD::get_dc1394_options ( const VideoSource &  vs,
ImageRef &  size,
float &  fps,
ImageRef &  offset,
bool &  verbose,
bool &  bus_reset,
int &  format7_mode 
)
void CVD::get_file_options ( const VideoSource &  vs,
int &  ra_frames,
VideoBufferFlags::OnEndOfBuffer &  eob 
)
void CVD::get_files_options ( const VideoSource &  vs,
int &  fps,
int &  ra_frames,
VideoBufferFlags::OnEndOfBuffer &  eob 
)
void CVD::get_jpegstream_options ( const VideoSource &  vs,
int &  fps 
)
void CVD::get_qt_options ( const VideoSource &  vs,
ImageRef &  size,
bool &  showsettings,
bool &  verbose 
)
double CVD::get_time_of_day (  ) 

Same as the system call gettimeofday, but returns time since the epoch as a double.

void CVD::get_v4l1_options ( const VideoSource &  vs,
ImageRef &  size 
)
void CVD::get_v4l2_options ( const VideoSource &  vs,
ImageRef &  size,
int &  input,
bool &  interlaced,
bool &  verbose 
)
template<class A , class B >
const B* CVD::getPixelRowTyped ( const A *  row,
int  n,
B *  rowbuf 
) [inline]

Definition at line 346 of file convolution.h.

std::vector< std::string > globlist ( const std::string &  gl  ) 

Make a list of strings from a UNIX-style pattern pathname expansion. Tilde expansion is done, and * ? [] and {} can all be used as normal. The filenames are returned in alphabetical (and numerical) order.

Parameters:
gl The pattern from which to generate the strings
void CVD::gradient ( const BasicImage< byte > &  im,
BasicImage< short[2]> &  out 
)
void CVD::halfSample ( const BasicImage< byte > &  in,
BasicImage< byte > &  out 
)
template<class C >
void CVD::harris_corner_detect ( const SubImage< C > &  i,
std::vector< ImageRef > &  c,
unsigned int  N,
float  blur = 1.0,
float  sigmas = 3.0 
) [inline]

Definition at line 176 of file harris_corner.h.

template<class I >
void CVD::img_load ( Image< I > &  im,
const std::string &  s 
) [inline]

Definition at line 263 of file image_io.h.

Internal::ImagePromise<Internal::ImageLoaderString> CVD::img_load ( const std::string &  s  ) 
Internal::ImagePromise<Internal::ImageLoaderIstream> CVD::img_load ( std::istream &  i  ) 
template<class PixelType >
void CVD::img_save ( const BasicImage< PixelType > &  im,
const std::string &  name,
const std::map< std::string, Parameter<> > &  p = std::map<std::string, Parameter<> >() 
) [inline]

Definition at line 334 of file image_io.h.

template<class PixelType >
void CVD::img_save ( const BasicImage< PixelType > &  im,
const std::string &  name,
ImageType::ImageType  t,
ImageType::ImageType  d = ImageType::PNM,
const std::map< std::string, Parameter<> > &  p = std::map<std::string, Parameter<> >() 
) [inline]

Definition at line 318 of file image_io.h.

double CVD::inner_product ( const double *  a,
const double *  b,
size_t  count 
)
double CVD::inner_product ( const float *  a,
const float *  b,
size_t  count 
)
template<class T >
double CVD::inner_product ( const T *  a,
const T *  b,
size_t  count 
) [inline]

Compute sum(a_i*b_i) This is accelerated using SIMD for some platforms and data types (alignment is checked at runtime) Do not specify template parameters explicitly so that overloading can choose the right implementation

Definition at line 156 of file utility.h.

template<class C >
Internal::ImagePromise<Internal::IntegralImage<C> > CVD::integral_image ( const SubImage< C > &  c  )  [inline]

Definition at line 84 of file integral_image.h.

template<int bytes>
bool CVD::is_aligned ( const void *  ptr  )  [inline]

Check if the pointer is aligned to the specified byte granularity.

template<>
bool CVD::is_aligned< 16 > ( const void *  ptr  )  [inline]
template<>
bool CVD::is_aligned< 8 > ( const void *  ptr  )  [inline]
template<class T >
VideoBuffer<T>* CVD::makeColourspaceBuffer ( const std::string &  c,
const std::string &  r 
) [inline]

Definition at line 110 of file videosource.h.

template<class Out , class In >
VideoBuffer<Out>* CVD::makeConvertBufferBit ( const std::string &  r  )  [inline]

Definition at line 105 of file videosource.h.

template<>
VideoBuffer< bayer_rggb16be > * CVD::makeDVBuffer2 ( int  cam,
ImageRef  size,
float  fps,
ImageRef  offset,
bool  verbose,
bool  bus_reset,
int  format7_mode 
) [inline]

Definition at line 227 of file videosource.h.

template<class T >
VideoBuffer<T>* CVD::makeDVBuffer2 ( int  ,
ImageRef  ,
float  ,
ImageRef  ,
bool  ,
bool  ,
int   
) [inline]

Definition at line 227 of file videosource.h.

template<>
VideoBuffer< Rgb< byte > > * CVD::makeQTBuffer ( const ImageRef &  size,
int  input,
bool  showsettings,
bool  verbose 
) [inline]

Definition at line 253 of file videosource.h.

template<class T >
VideoBuffer<T>* CVD::makeQTBuffer ( const ImageRef &  ,
int  ,
bool  ,
bool   
) [inline]

Definition at line 253 of file videosource.h.

template<>
VideoBuffer< Rgb< byte > > * CVD::makeV4L1Buffer ( const std::string &  dev,
const ImageRef &  size 
) [inline]

Definition at line 176 of file videosource.h.

template<class T >
VideoBuffer<T>* CVD::makeV4L1Buffer ( const std::string &  ,
const ImageRef &   
) [inline]

Definition at line 176 of file videosource.h.

template<>
VideoBuffer< Rgb8 > * CVD::makeV4LBuffer ( const std::string &  dev,
const ImageRef &  size,
int  input,
bool  interlaced,
bool  verbose 
) [inline]

Definition at line 193 of file videosource.h.

template<class T >
VideoBuffer<T>* CVD::makeV4LBuffer ( const std::string &  ,
const ImageRef &  ,
int  ,
bool  ,
bool   
) [inline]

Definition at line 193 of file videosource.h.

template<>
VideoBuffer< Rgb< byte > > * CVD::makeVideoFileBuffer ( const std::string &  file,
VideoBufferFlags::OnEndOfBuffer  eob 
) [inline]

Definition at line 213 of file videosource.h.

template<class T >
VideoBuffer<T>* CVD::makeVideoFileBuffer ( const std::string &  ,
VideoBufferFlags::OnEndOfBuffer   
) [inline]

Definition at line 213 of file videosource.h.

void CVD::median_filter_3x3 ( const SubImage< byte > &  I,
SubImage< byte >  out 
)
template<class T >
void CVD::median_filter_3x3 ( const SubImage< T > &  I,
SubImage< T >  out 
) [inline]

Definition at line 502 of file vision.h.

void CVD::morphology ( const SubImage< byte > &  in,
const std::vector< ImageRef > &  selem,
const Morphology::Median< byte > &  m,
SubImage< byte > &  out 
)

Definition at line 618 of file morphology.h.

template<class C , class D >
Internal::ImagePromise<Internal::PerformMorphology<C, D> > CVD::morphology ( const SubImage< C > &  c,
const std::vector< ImageRef > &  selem,
const D &  a 
) [inline]

Definition at line 296 of file morphology.h.

template<class T >
VideoBuffer<T>* CVD::open_video_source ( const VideoSource &  vs  )  [inline]

Definition at line 269 of file videosource.h.

template<class T , class S >
La<T> CVD::operator* ( const S &  b,
const La< T > &  a 
) [inline]

Definition at line 244 of file rgb_components.h.

template<class T , class S >
La<T> CVD::operator* ( const La< T > &  a,
const S &  b 
) [inline]

Definition at line 243 of file rgb_components.h.

template<class T , class S >
Rgba<T> CVD::operator* ( const S &  b,
const Rgba< T > &  a 
) [inline]

Definition at line 221 of file rgb_components.h.

template<class T , class S >
Rgba<T> CVD::operator* ( const Rgba< T > &  a,
const S &  b 
) [inline]

Definition at line 220 of file rgb_components.h.

template<class T , class S >
Rgb<T> CVD::operator* ( const S &  b,
const Rgb< T > &  a 
) [inline]

Definition at line 197 of file rgb_components.h.

template<class T , class S >
Rgb<T> CVD::operator* ( const Rgb< T > &  a,
const S &  b 
) [inline]

Definition at line 196 of file rgb_components.h.

ImageRef CVD::operator* ( const int  scale,
const ImageRef &  ref 
) [related]

Definition at line 191 of file image_ref.h.

template<class T , class S >
La<T>& CVD::operator*= ( La< T > &  a,
const S &  b 
) [inline]

Definition at line 245 of file rgb_components.h.

template<class T , class S >
Rgba<T>& CVD::operator*= ( Rgba< T > &  a,
const S &  b 
) [inline]

Definition at line 222 of file rgb_components.h.

template<class T , class S >
Rgb<T>& CVD::operator*= ( Rgb< T > &  a,
const S &  b 
) [inline]

Definition at line 198 of file rgb_components.h.

template<class T , class S >
La<T> CVD::operator+ ( const La< T > &  a,
const La< S > &  b 
) [inline]

Definition at line 239 of file rgb_components.h.

template<class T , class S >
Rgba<T> CVD::operator+ ( const Rgba< T > &  a,
const Rgba< S > &  b 
) [inline]

Definition at line 216 of file rgb_components.h.

template<class T , class S >
Rgb<T> CVD::operator+ ( const Rgb< T > &  a,
const Rgb< S > &  b 
) [inline]

Definition at line 192 of file rgb_components.h.

template<class T , class S >
La<T>& CVD::operator+= ( La< T > &  a,
const La< S > &  b 
) [inline]

Definition at line 240 of file rgb_components.h.

template<class T , class S >
Rgba<T>& CVD::operator+= ( Rgba< T > &  a,
const Rgba< S > &  b 
) [inline]

Definition at line 217 of file rgb_components.h.

template<class T , class S >
Rgb<T>& CVD::operator+= ( Rgb< T > &  a,
const Rgb< S > &  b 
) [inline]

Definition at line 193 of file rgb_components.h.

template<class T , class S >
La<T> CVD::operator- ( const La< T > &  a,
const La< S > &  b 
) [inline]

Definition at line 241 of file rgb_components.h.

template<class T , class S >
Rgba<T> CVD::operator- ( const Rgba< T > &  a,
const Rgba< S > &  b 
) [inline]

Definition at line 218 of file rgb_components.h.

template<class T , class S >
Rgb<T> CVD::operator- ( const Rgb< T > &  a,
const Rgb< S > &  b 
) [inline]

Definition at line 194 of file rgb_components.h.

template<class T , class S >
La<T>& CVD::operator-= ( La< T > &  a,
const La< S > &  b 
) [inline]

Definition at line 242 of file rgb_components.h.

template<class T , class S >
Rgba<T>& CVD::operator-= ( Rgba< T > &  a,
const Rgba< S > &  b 
) [inline]

Definition at line 219 of file rgb_components.h.

template<class T , class S >
Rgb<T>& CVD::operator-= ( Rgb< T > &  a,
const Rgb< S > &  b 
) [inline]

Definition at line 195 of file rgb_components.h.

template<class T , class S >
La<T> CVD::operator/ ( const S &  b,
const La< T > &  a 
) [inline]

Definition at line 247 of file rgb_components.h.

template<class T , class S >
La<T> CVD::operator/ ( const La< T > &  a,
const S &  b 
) [inline]

Definition at line 246 of file rgb_components.h.

template<class T , class S >
Rgba<T> CVD::operator/ ( const S &  b,
const Rgba< T > &  a 
) [inline]

Definition at line 224 of file rgb_components.h.

template<class T , class S >
Rgba<T> CVD::operator/ ( const Rgba< T > &  a,
const S &  b 
) [inline]

Definition at line 223 of file rgb_components.h.

template<class T , class S >
Rgb<T> CVD::operator/ ( const S &  b,
const Rgb< T > &  a 
) [inline]

Definition at line 200 of file rgb_components.h.

template<class T , class S >
Rgb<T> CVD::operator/ ( const Rgb< T > &  a,
const S &  b 
) [inline]

Definition at line 199 of file rgb_components.h.

template<class T , class S >
La<T>& CVD::operator/= ( La< T > &  a,
const S &  b 
) [inline]

Definition at line 248 of file rgb_components.h.

template<class T , class S >
Rgba<T>& CVD::operator/= ( Rgba< T > &  a,
const S &  b 
) [inline]

Definition at line 225 of file rgb_components.h.

template<class T , class S >
Rgb<T>& CVD::operator/= ( Rgb< T > &  a,
const S &  b 
) [inline]

Definition at line 201 of file rgb_components.h.

std::ostream& CVD::operator<< ( std::ostream &  out,
const VideoSource &  vs 
)
void CVD::parse ( std::istream &  in,
VideoSource &  vs 
)
template<int I>
void CVD::prefetch ( const void *  ptr  )  [inline]

Prefetch memory. This function might do nothing, depending on the architecture, or it might prefetch memory. Either way it will have no effect on the computation except to (possibly) speed it up.

Parameters:
ptr The address of the memory to prefetch.
I The type of prefetch. This depends on the architecture.

  • x86, MMXEXT
    • 0: prefetcht0
    • 1: prefetcht1
    • 2: prefetcht2
    • *: prefetchnta (default)
  • Everything else
    • *: nothing

Definition at line 105 of file cpu_hacks.h.

void CVD::sample ( const BasicImage< float > &  im,
double  x,
double  y,
float &  result 
) [inline]

Definition at line 294 of file vision.h.

template<class T , class S >
T CVD::sample ( const BasicImage< S > &  im,
double  x,
double  y 
) [inline]

Definition at line 288 of file vision.h.

template<class T , class S >
void CVD::sample ( const BasicImage< S > &  im,
double  x,
double  y,
T &  result 
) [inline]

Definition at line 273 of file vision.h.

template<class C >
void CVD::shitomasi_corner_detect ( const SubImage< C > &  i,
std::vector< ImageRef > &  c,
unsigned int  N,
float  blur = 1.0,
float  sigmas = 3.0 
) [inline]

Definition at line 182 of file harris_corner.h.

void CVD::square ( const float *  in,
float *  out,
size_t  count 
)
template<class T1 , class T2 >
void CVD::square ( const T1 *  in,
T2 *  out,
size_t  count 
) [inline]

Definition at line 174 of file utility.h.

template<int A, class T >
size_t CVD::steps_to_align ( const T *  ptr  )  [inline]

Compute the number of pointer increments necessary to yield alignment of A bytes.

Definition at line 203 of file utility.h.

ImageType::ImageType CVD::string_to_image_type ( const std::string &  name  ) 

Deduce an image type from a filename suffix.

Parameters:
name The name of the image file
void CVD::subtract_square ( const float *  in,
float *  out,
size_t  count 
)
template<class T1 , class T2 >
void CVD::subtract_square ( const T1 *  in,
T2 *  out,
size_t  count 
) [inline]

Definition at line 182 of file utility.h.

long long CVD::sum_squared_differences ( const byte *  a,
const byte *  b,
size_t  count 
)
double CVD::sum_squared_differences ( const double *  a,
const double *  b,
size_t  count 
)
double CVD::sum_squared_differences ( const float *  a,
const float *  b,
size_t  count 
)
template<class T >
double CVD::sum_squared_differences ( const T *  a,
const T *  b,
size_t  count 
) [inline]

Compute sum of (a_i - b_i)^2 (the SSD) This is accelerated using SIMD for some platforms and data types (alignment is checked at runtime) Do not specify template parameters explicitly so that overloading can choose the right implementation

Definition at line 193 of file utility.h.

template<class C >
Internal::ImagePromise<Internal::twoThirdsSampler<C> > CVD::twoThirdsSample ( const SubImage< C > &  c  )  [inline]

Definition at line 96 of file vision.h.

void CVD::twoThirdsSample ( const SubImage< byte > &  in,
SubImage< byte > &  out 
)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void CVD::van_vliet_blur ( const double  b[],
const SubImage< float >  in,
SubImage< float >  out 
)
template<class T >
void CVD::zeroBorders ( BasicImage< T > &  I  )  [inline]

Set the one-pixel border (top, bottom, sides) of an image to zero values.

Definition at line 89 of file utility.h.

template<class T >
void CVD::zeroPixel ( T &  pixel  )  [inline]

Set a pixel to the default value (typically 0) For multi-component pixels, this zeros all components (sets them to defaults)

Definition at line 82 of file utility.h.

template<class T >
void CVD::zeroPixels ( T *  pixels,
int  count 
) [inline]

Set many pixels to the default value (typically 0) For multi-component pixels, this zeros all components (sets them to defaults)

Definition at line 86 of file utility.h.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

libcvd
Author(s): Edward Rosten, Paul Smith, Tom Drummond, Gerhard Reitmayr, Ethan Eade, Timothy Gan, Chris Kemp, Georg Klein
autogenerated on Fri Jan 11 09:13:50 2013