Classes | |
| class | Brezenham |
| Class to implement the Bresenham line-drawing algorithm. More... | |
| class | Brezenham8 |
| Class to implement the Bresenham line-drawing algorithm. More... | |
| class | ColourspaceFrame |
| A frame from a ColourspaceBuffer. Can be treated as a VideoFrame. More... | |
| class | ColourspaceBuffer |
| A decorator class which wraps a VideoBuffer to perfrom colourspace conversion on the incoming data. More... | |
| class | ColourspaceBuffer_managed |
| This is just like ColourspaceBuffer, except it deleted the videobuffer on destruction. More... | |
| struct | bayer |
| A dedicated bayer datatype to configure the V4L1 device to return bayer images. More... | |
| struct | yuv411 |
| A datatype to represent yuv411 (uyyvyy) data, typically from firewire cameras. More... | |
| struct | yuv422 |
| A datatype to represent yuv422 (yuyv) data. More... | |
| struct | yuv420p |
| A datatype to represent yuv420p (yy. More... | |
| struct | vuy422 |
| A datatype to represent the other yuv422 (uyvy) data. More... | |
| struct | GetPixelRowTyped |
| struct | GetPixelRowTyped< T, T > |
| struct | CastCopy |
| struct | CastCopy< T, T > |
| struct | ConvolveMiddle |
| struct | ConvolveMiddle< T, N, 1 > |
| struct | ConvolveMiddle< T,-1, 1 > |
| struct | ConvolveMiddle< T,-1, C > |
| struct | ConvolveMiddle< T, 0, 1 > |
| class | DeinterlaceBuffer |
| A decorator class which wraps a VideoBuffer to return fields instead of the original frames (see also DeinterlaceFrame). More... | |
| class | DeinterlaceFrame |
| A frame from a DeinterlaceBuffer, representing one field from an interlaced frame. More... | |
| class | DiskBuffer2 |
| Play a series of image files as a video stream. More... | |
| class | DiskBuffer2Frame |
| A frame from a DiskBuffer2. More... | |
| struct | color |
| traits type defining colors for pixel types More... | |
| struct | color< T, 1 > |
| traits type defining colors for pixel types. More... | |
| struct | color< T, 3 > |
| traits type defining colors for pixel types. More... | |
| class | EventObject |
| Encapsulation of a condition variable and its boolean condition. More... | |
| class | GLWindow |
| An object that creates a window and a GL context attached to that window, and manages its events. More... | |
| class | ConstSubImageIterator |
| class | SubImageIterator |
| class | SubImageIteratorEnd |
| class | ConstSubImageIteratorEnd |
| class | SubImage |
| A generic image class to manage a block of arbitrarily padded data as an image. More... | |
| class | BasicImage |
| A generic image class to manage a block of data as an image. More... | |
| class | ImageCreationIterator |
| An input iterator which just returns N copies of the same value over and over again. More... | |
| class | Image |
| A full image which manages its own data. More... | |
| struct | ConvertImage |
| class | image_interpolate |
| This is a generic interpolation class which wraps in image and provides a similar interface for floating point pixel positions. More... | |
| class | ImageRef |
| struct | RobustI |
| Robust reweighting (type I) for IRLS. More... | |
| struct | RobustII |
| Robust reweighting (type II) for IRLS. More... | |
| struct | ILinear |
| A reweighting class representing no reweighting in IRLS. More... | |
| class | IRLS |
| Performs iterative reweighted least squares. More... | |
| class | La |
| A colour consisting of luminance and alpha components. More... | |
| class | LocalVideoBuffer |
| Base class for a VideoBuffer which manages its own memory for each VideoFrame that it provides. More... | |
| class | LocalVideoFrame |
| A frame from a LocalVideoBuffer, which manages its own data rather than wrapping data owned by the system. More... | |
| class | MessageQueue |
| This class provides a simple, thread safe FIFO message queue. More... | |
| class | ReadAheadVideoBuffer |
| Decorator video buffer that preloads frames asynchronously in a separate thread. More... | |
| class | Rgb |
| A colour consisting of red, green and blue components. More... | |
| struct | Rgb8 |
| class | Rgba |
| A colour consisting of red, green, blue and alpha components. More... | |
| class | RingBuffer |
| Implements a ringbuffer based on std::vector. More... | |
| class | Runnable |
| This is an abstract base class for anything with a run() method. More... | |
| class | RunnableBatch |
| This class provides a simple job manager for tasks derived from CVD:Runnable. More... | |
| class | ServerPushJpegBuffer |
| Play a server push stream as a video stream. More... | |
| class | ServerPushJpegFrame |
| class | Synchronized |
| A Synchronized object encapsulates a basic mutex. More... | |
| struct | Lock |
| A utility class for locking and unlocking Synchronized objects automatically. More... | |
| class | Thread |
| The Thread class encapsulates a thread of execution. More... | |
| class | TimedDiskBuffer |
| Play a series of image files as a video stream and use a list of provided timestamps. More... | |
| class | cvd_timer |
| Provides the time elapsed in seconds. More... | |
| struct | ZeroPixel |
| struct | ZeroPixel< T, true > |
| struct | ZeroPixels |
| struct | ZeroPixels< T, true > |
| struct | SumSquaredDifferences |
| class | VideoBufferData |
| Base class for objects that a video buffer can manage the lifetime of. More... | |
| class | VideoBufferDataAuto |
| struct | VideoBufferType |
| The semsntics of the videobuffer. See VideoFrame::type(). More... | |
| class | VideoBuffer |
| Base class for objects which provide a video stream. More... | |
| class | VideoDisplay |
| A cheap and cheerful GL display window using X and the GLX library. More... | |
| class | VideoFileBuffer |
| A video buffer to play frames from a video file. More... | |
| class | VideoFileFrame |
| A frame from a VideoFileBuffer. More... | |
| class | VideoFrame |
| A frame from a VideoBuffer. More... | |
| struct | ParseException |
| struct | VideoSourceException |
| struct | VideoSource |
| struct | multiplyBy |
| a functor multiplying pixels with constant value. More... | |
| struct | Gradient< S, T, 1, 2 > |
| struct | YC |
| class | O2Buffer |
| A video buffer to play live video on an SGI O2. More... | |
| class | O2VideoFrame |
| A frame from an O2Buffer. More... | |
| class | DVBuffer2 |
| A video buffer from a Firewire (IEEE 1394) camera. More... | |
| class | DVBuffer3 |
| A video buffer from a Firewire (IEEE 1394) camera. More... | |
| class | DVFrame |
| A frame from a Firewire (IEEE 1394) camera via DVBuffer2. More... | |
| class | V4L1Buffer |
| A video buffer from a v4l1 video device. More... | |
| class | V4L1Frame |
| A frame from a V4L1Buffer. More... | |
| struct | V4L2_Traits< unsigned char > |
| class | V4L2Buffer_Base |
| A live video buffer from a the framegrabber (using the Video for Linux 2 API). More... | |
| class | V4L2BufferT |
| class | V4L2FrameT |
| A frame from a V4L2Buffer This is an 8-bit greyscale video frame. More... | |
| class | V4LBuffer |
| A live video buffer which uses the Video for Linux 2 (V4L2) API. More... | |
| class | V4LControl |
| exposes the V4L2 API to set parameters on a capture device. More... | |
| struct | Less |
| struct | Greater |
| struct | ConvertImage< T, T, Pixel::GenericConversion< T, T >, 1 > |
| struct | ConvertImage< Rgb< byte >, byte, Pixel::CIE< Rgb< byte >, byte >, 1 > |
| struct | V4L2_Traits< CVD::YC > |
Namespaces | |
| namespace | ColourSpace |
| namespace | Pixel |
| namespace | Exceptions |
| namespace | Internal |
| namespace | Harris |
| namespace | ImageError |
| namespace | ImageUtil |
| namespace | Interpolate |
| namespace | ImageType |
| namespace | VideoBufferFlags |
| namespace | VFB |
| namespace | VideoFrameFlags |
| namespace | median |
| namespace | SGI |
| namespace | DC |
| namespace | DV3 |
| namespace | V4L1 |
| namespace | V4L |
Typedefs | |
| typedef Brezenham | Bresenham |
| typedef Brezenham8 | Bresenham8 |
| typedef unsigned char | byte |
| typedef DVBuffer2< byte > | DVBuffer |
| typedef V4L1Buffer < byte > | V4L1BufferByte |
| typedef V4L2BufferT < unsigned char > | V4L2Buffer |
| typedef V4L2FrameT < unsigned char > | V4L2Frame |
Enumerations | |
| enum | TEXT_STYLE { FILL = 0, OUTLINE = 1, NICE = 2 } |
| enum | V4L2BufferBlockMethod { V4L2BBMselect, V4L2BBMsleep, V4L2BBMchew } |
Functions | |
| template<class T> | |
| T | abs (T t) |
| unsigned char | abs (unsigned char b) |
| unsigned short | abs (unsigned short u) |
| unsigned int | abs (unsigned int u) |
| unsigned long | abs (unsigned long u) |
| template<> | |
| void | convert_image (const BasicImage< bayer > &from, BasicImage< byte > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer > &from, BasicImage< Rgb< byte > > &to) |
| template<> | |
| void | convert_image (const BasicImage< yuv411 > &from, BasicImage< Rgb< byte > > &to) |
| template<> | |
| void | convert_image (const BasicImage< yuv411 > &from, BasicImage< byte > &to) |
| template<> | |
| void | convert_image (const BasicImage< yuv422 > &from, BasicImage< Rgb< byte > > &to) |
| template<> | |
| void | convert_image (const BasicImage< yuv422 > &from, BasicImage< byte > &to) |
| template<> | |
| std::pair< Image < byte >, Image< Rgb < byte > > > | convert_image_pair (const BasicImage< yuv411 > &from) |
| template<> | |
| void | convert_image (const BasicImage< vuy422 > &from, BasicImage< Rgb< byte > > &to) |
| template<> | |
| void | convert_image (const BasicImage< vuy422 > &from, BasicImage< byte > &to) |
| void | connected_components (const std::vector< ImageRef > &v, std::vector< std::vector< ImageRef > > &r) |
| template<class T> | |
| T | gaussianKernel (std::vector< T > &k, T maxval, double stddev) |
| template<class S, class T> | |
| T | scaleKernel (const std::vector< S > &k, std::vector< T > &scaled, T maxval) |
| template<class T> | |
| void | convolveGaussian5_1 (BasicImage< T > &I) |
| template<class T> | |
| void | convolveWithBox (const BasicImage< T > &I, BasicImage< T > &J, ImageRef hwin) |
| template<class T> | |
| void | convolveWithBox (const BasicImage< T > &I, BasicImage< T > &J, int hwin) |
| template<class T> | |
| void | convolveWithBox (BasicImage< T > &I, int hwin) |
| template<class T> | |
| void | convolveWithBox (BasicImage< T > &I, ImageRef hwin) |
| template<class T, int A, int B, int C> | |
| void | convolveSymmetric (Image< T > &I) |
| template<class T, class K> | |
| void | convolveSeparableSymmetric (Image< T > &I, const std::vector< K > &kernel, K divisor) |
| template<class A, class B> | |
| const B * | getPixelRowTyped (const A *row, int n, B *rowbuf) |
| template<class T, class S> | |
| void | cast_copy (const T *from, S *to, int count) |
| 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> | |
| void | convolveGaussian (BasicImage< T > &I, double sigma, double sigmas=3.0) |
| template<class T> | |
| void | convolveGaussian (const BasicImage< T > &I, BasicImage< T > &out, double sigma, double sigmas=3.0) |
| void | compute_van_vliet_b (double sigma, double b[]) |
| void | compute_triggs_M (const double b[], double M[][3]) |
| void | van_vliet_blur (const double b[], const SubImage< float > in, SubImage< float > out) |
| void | convolveGaussian (const BasicImage< float > &I, BasicImage< float > &out, double sigma, double sigmas=3.0) |
| void | convolveGaussian_fir (const BasicImage< float > &I, BasicImage< float > &out, double sigma, double sigmas=3.0) |
| template<class T, class O, class K> | |
| void | convolve_gaussian_3 (const BasicImage< T > &I, BasicImage< O > &out, K k1, K k2) |
| void | enableFPE () |
| template<int I> | |
| void | prefetch (const void *ptr) |
| std::vector < std::string > | globlist (const std::string &gl) |
| template<class T> | |
| void | drawLine (Image< T > &im, double x1, double y1, double x2, double y2, const T &c) |
| template<class T> | |
| void | drawLine (Image< T > &im, const ImageRef &p1, const ImageRef &p2, const T &c) |
| template<class T> | |
| void | drawLine (Image< T > &im, const TooN::Vector< 2 > &p1, const TooN::Vector< 2 > &p2, const T &c) |
| template<class T> | |
| void | drawShape (Image< T > &im, const ImageRef &offset, const std::vector< ImageRef > &points, const T &c) |
| template<class T> | |
| void | drawBox (Image< T > &im, const ImageRef &upperleft, const ImageRef &lowerright, const T &c) |
| template<class T> | |
| void | drawCross (Image< T > &im, const ImageRef &p, double len, const T &c) |
| std::vector< ImageRef > | getCircle (int radius) |
| std::vector< ImageRef > | getDisc (float radius) |
| template<class S, class T, class U> | |
| void | joinImages (const Image< S > &a, const Image< T > &b, Image< U > &J) |
| 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 | 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) |
| void | fast_corner_detect_7 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier) |
| void | fast_corner_score_7 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores) |
| void | fast_corner_detect_8 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier) |
| void | fast_corner_score_8 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores) |
| void | fast_corner_detect_9 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier) |
| void | fast_corner_score_9 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores) |
| void | fast_corner_detect_9_nonmax (const BasicImage< byte > &im, std::vector< ImageRef > &max_corners, int barrier) |
| void | fast_corner_detect_10 (const BasicImage< byte > &im, std::vector< ImageRef > &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_detect_11 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier) |
| void | fast_corner_score_11 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores) |
| void | fast_corner_detect_12 (const BasicImage< byte > &im, std::vector< ImageRef > &corners, int barrier) |
| void | fast_corner_score_12 (const SubImage< byte > &i, const std::vector< ImageRef > &corners, int b, std::vector< int > &scores) |
| void | glVertex (const ImageRef &i) |
| void | glTexCoord (const ImageRef &i) |
| void | glRasterPos (const ImageRef &i) |
| template<class P1, class P2> | |
| void | glLine (const P1 &x1, const P2 &x2) |
| void | glVertex (const TooN::Vector< 2 > &v) |
| void | glVertex (const TooN::Vector< 3 > &v) |
| void | glVertex (const TooN::Vector< 4 > &v) |
| void | glTexCoord (const TooN::Vector< 2 > &v) |
| void | glTexCoord (const TooN::Vector< 3 > &v) |
| void | glTexCoord (const TooN::Vector< 4 > &v) |
| void | glRasterPos (const TooN::Vector< 2 > &v) |
| void | glRasterPos (const TooN::Vector< 3 > &v) |
| void | glRasterPos (const TooN::Vector< 4 > &v) |
| void | glNormal (const TooN::Vector< 3 > &n) |
| void | glTranslate (const ImageRef &v) |
| template<int N> | |
| void | glTranslate (const TooN::Vector< N > &v) |
| template<> | |
| void | glTranslate (const TooN::Vector< 2 > &v) |
| template<> | |
| void | glTranslate (const TooN::Vector< 1 > &v) |
| template<int N, class A> | |
| void | glMultMatrix (const TooN::FixedMatrix< N, N, A > &m) |
| template<class A> | |
| void | glMultMatrix (const TooN::FixedMatrix< 3, 3, A > &m) |
| template<class A> | |
| void | glMultMatrix (const TooN::FixedMatrix< 2, 2, A > &m) |
| void | glMultMatrix (const CVD::SO3 &so3) |
| void | glMultMatrix (const CVD::SE3 &se3) |
| void | glMultMatrix (const CVD::SO2 &so2) |
| void | glMultMatrix (const CVD::SE2 &se2) |
| void | glOrtho (const CVD::ImageRef &size, const double nearPlane=-1.0, const double farPlane=1.0) |
| void | glOrtho (const TooN::Vector< 6 > ¶m) |
| template<class A> | |
| void | glFrustum (const TooN::FixedVector< 4, A > ¶ms, double width, double height, double near=0.1, double far=100) |
| template<class CAMERA> | |
| void | glFrustum (const CAMERA &camera, double width, double height, double near=0.1, double far=100) |
| void | glFrustum (const TooN::Vector< 6 > ¶m) |
| void | glColor (const TooN::Vector< 3 > &v) |
| void | glColor (const TooN::Vector< 4 > &v) |
| void | glClearColor (const TooN::Vector< 4 > &v) |
| void | glClearColor (const TooN::Vector< 3 > &v) |
| void | glColor (const TooN::Vector<-1 > &v) |
| template<class C> | |
| void | glVertex (const C &list) |
| void | glColor (const CVD::Rgb< byte > &c) |
| void | glColor (const CVD::Rgb< float > &c) |
| void | glColor3 (const CVD::Rgb8 &c) |
| void | glColor4 (const CVD::Rgb8 &c) |
| void | glColor (const CVD::Rgba< unsigned char > &c) |
| void | glColor (const CVD::Rgba< float > &c) |
| template<class C> | |
| void | glDrawPixels (const SubImage< C > &i) |
| template<class C> | |
| void | glReadPixels (BasicImage< C > &i, ImageRef origin=ImageRef(0, 0)) |
| template<class C> | |
| Image< C > | glReadPixels (ImageRef size, ImageRef origin=ImageRef(0, 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 | glTexImage2D (const SubImage< C > &i, GLint border=0, GLenum target=GL_TEXTURE_2D, GLint level=0) |
| void | glPrintErrors (void) |
| void | glSetFont (const std::string &fontname) |
| const std::string & | glGetFont () |
| 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) |
| template<class It> | |
| void | haar1D (It from, It to) |
| template<class It> | |
| void | haar1D (It from, int size) |
| template<class It> | |
| void | haar2D (It from, const int width, const int height, int stride=-1) |
| template<class T> | |
| void | haar2D (SubImage< T > &I) |
| template<class Score, class Inserter, class C, class B> | |
| void | harrislike_corner_detect (const BasicImage< B > &i, C &c, unsigned int N, float blur, float sigmas, BasicImage< float > &xx, BasicImage< float > &xy, BasicImage< float > &yy) |
| template<class C> | |
| void | harris_corner_detect (const Image< C > &i, std::vector< ImageRef > &c, unsigned int N, float blur=1.0, float sigmas=3.0) |
| template<class C> | |
| void | shitomasi_corner_detect (const Image< C > &i, std::vector< ImageRef > &c, unsigned int N, float blur=1.0, float sigmas=3.0) |
| template<class C> | |
| ImageCreationIterator < C > | CreateImagesBegin (const C &from_me) |
| template<class C> | |
| ImageCreationIterator < C > | CreateImagesEnd (const C &, int i) |
| template<class C> | |
| ImageCreationIterator < C > | CreateImagesEnd (int i) |
| template<class Conv, class C, class D> | |
| void | convert_image (const SubImage< C > &from, SubImage< D > &to) |
| template<class C, class D> | |
| void | convert_image (const BasicImage< C > &from, BasicImage< D > &to) |
| template<class D, class Conv, class C> | |
| Image< D > | convert_image (const SubImage< C > &from) |
| template<class D, class C> | |
| Image< D > | convert_image (const BasicImage< C > &from) |
| template<class D1, class D2, class C> | |
| std::pair< Image< D1 >, Image< D2 > > | convert_image_pair (const BasicImage< C > &from) |
| template<class C> | |
| Image< C > | img_load (std::istream &i) |
| template<class C> | |
| Image< C > | img_load (std::string &i) |
| template<class I> | |
| void | img_load (Image< I > &im, std::istream &i) |
| template<class I> | |
| void | img_load (Image< I > &im, const std::string &s) |
| ImageType::ImageType | string_to_image_type (const std::string &name) |
| template<class PixelType> | |
| void | img_save (const BasicImage< PixelType > &im, std::ostream &o, ImageType::ImageType t) |
| template<class PixelType> | |
| void | img_save (const BasicImage< PixelType > &im, const std::string &name, ImageType::ImageType t, ImageType::ImageType d=ImageType::PNM) |
| template<class PixelType> | |
| void | img_save (const BasicImage< PixelType > &im, const std::string &name) |
| template<class PixelType> | |
| void | pnm_save (const BasicImage< PixelType > &im, std::ostream &o) |
| template<class PixelType> | |
| void | pnm_load (Image< PixelType > &im, std::istream &i) |
| void | output_eps_footer (std::ostream &o) |
| void | output_eps_header (std::ostream &o, int xs, int ys) |
| void | output_eps_header (std::ostream &o, const ImageRef &s) |
| template<class PixelType> | |
| void | output_eps_header (std::ostream &o, const BasicImage< PixelType > &im) |
| ImageRef | operator * (const int scale, const ImageRef &ref) |
| template<class S, class D> | |
| void | integral_image (const SubImage< S > &in, SubImage< D > &out) |
| template<class S, class D> | |
| Image< D > | integral_image (const BasicImage< S > &from) |
| double | interpolate_extremum (double d1, double d2, double d3) |
| TooN::Vector< 2 > | interpolate_extremum (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 I> | |
| TooN::Vector< 2 > | interpolate_extremum (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 I> | |
| std::pair < TooN::Vector< 2 >, double > | interpolate_extremum_value (const SubImage< I > &i, ImageRef p) |
| void | nonmax_suppression_strict (const std::vector< ImageRef > &corners, const std::vector< int > &scores, std::vector< ImageRef > &nmax_corners) |
| void | nonmax_suppression (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) |
| double | rand_u () |
| double | rand_g () |
| 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) |
| double | get_time_of_day () |
| 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 T> | |
| void | zeroPixel (T &pixel) |
| template<class T> | |
| void | zeroPixels (T *pixels, int count) |
| template<class T> | |
| void | zeroBorders (BasicImage< T > &I) |
| template<class A, class B> | |
| void | differences (const A *a, const A *b, B *diff, size_t count) |
| template<class A, class B> | |
| void | add_multiple_of_sum (const A *a, const A *b, const float &c, B *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> | |
| double | inner_product (const T *a, const T *b, size_t count) |
| template<class T1, class T2> | |
| void | square (const T1 *in, T2 *out, size_t count) |
| template<class T1, class T2> | |
| void | subtract_square (const T1 *in, T2 *out, size_t count) |
| template<class T> | |
| double | sum_squared_differences (const T *a, const T *b, size_t count) |
| template<int bytes> | |
| bool | is_aligned (const void *ptr) |
| template<> | |
| bool | is_aligned< 8 > (const void *ptr) |
| template<> | |
| bool | is_aligned< 16 > (const void *ptr) |
| template<int A, class T> | |
| size_t | steps_to_align (const T *ptr) |
| void | differences (const byte *a, const byte *b, short *diff, unsigned int size) |
| void | differences (const short *a, const short *b, short *diff, unsigned int size) |
| void | differences (const float *a, const float *b, float *diff, size_t size) |
| void | add_multiple_of_sum (const float *a, const float *b, const float &c, float *out, size_t count) |
| void | assign_multiple (const float *a, const float &c, float *out, size_t count) |
| double | inner_product (const float *a, const float *b, size_t count) |
| double | sum_squared_differences (const float *a, const float *b, size_t count) |
| void | square (const float *in, float *out, size_t count) |
| void | subtract_square (const float *in, float *out, size_t count) |
| void | differences (const int32_t *a, const int32_t *b, int32_t *diff, size_t size) |
| void | differences (const double *a, const double *b, double *diff, size_t size) |
| void | add_multiple_of_sum (const double *a, const double *b, const float &c, double *out, size_t count) |
| void | assign_multiple (const double *a, const double &c, double *out, size_t count) |
| double | inner_product (const double *a, const double *b, size_t count) |
| double | sum_squared_differences (const double *a, const double *b, size_t count) |
| long long | sum_squared_differences (const byte *a, const byte *b, size_t count) |
| TooN::Vector< 2 > | vec (const ImageRef &ir) |
| ImageRef | ir (const TooN::Vector< 2 > &v) |
| ImageRef | ir_rounded (const TooN::Vector< 2 > &v) |
| std::ostream & | operator<< (std::ostream &out, const VideoSource &vs) |
| void | parse (std::istream &in, VideoSource &vs) |
| template<class T> | |
| VideoBuffer< T > * | makeJPEGStream (const std::string &filename) |
| void | get_jpegstream_options (const VideoSource &vs, int &fps) |
| template<class T> | |
| VideoBuffer< T > * | makeDiskBuffer2 (const std::vector< std::string > &files, double fps, VideoBufferFlags::OnEndOfBuffer eob) |
| void | get_files_options (const VideoSource &vs, int &fps, int &ra_frames, VideoBufferFlags::OnEndOfBuffer &eob) |
| template<class T> | |
| VideoBuffer< T > * | makeV4L1Buffer (const std::string &, const ImageRef &) |
| void | get_v4l1_options (const VideoSource &vs, ImageRef &size) |
| template<class T> | |
| VideoBuffer< T > * | makeV4LBuffer (const std::string &dev, const ImageRef &size, int input, bool interlaced, bool verbose) |
| void | get_v4l2_options (const VideoSource &vs, ImageRef &size, int &input, bool &interlaced, bool &verbose) |
| template<class T> | |
| VideoBuffer< T > * | makeVideoFileBuffer (const std::string &, VideoBufferFlags::OnEndOfBuffer) |
| void | get_file_options (const VideoSource &vs, int &ra_frames, VideoBufferFlags::OnEndOfBuffer &eob) |
| template<class T> | |
| VideoBuffer< T > * | makeDVBuffer2 (int, int, int, int, int) |
| void | get_dc1394_options (const VideoSource &vs, int &dma_bufs, int &bright, int &exposure, int &fps) |
| template<class T> | |
| VideoBuffer< T > * | open_video_source (const VideoSource &vs) |
| template<class T> | |
| VideoBuffer< T > * | open_video_source (std::istream &in) |
| template<class T> | |
| VideoBuffer< T > * | open_video_source (const std::string &src) |
| template<class T> | |
| void | halfSample (const BasicImage< T > &in, BasicImage< T > &out) |
| void | halfSample (const BasicImage< byte > &in, BasicImage< byte > &out) |
| template<class T> | |
| Image< T > | halfSample (const BasicImage< T > &in) |
| template<class T> | |
| Image< T > | halfSample (Image< T > in, unsigned int octaves) |
| template<class T> | |
| void | threshold (BasicImage< T > &im, const T &minimum, const T &hi) |
| template<class T> | |
| void | stats (const BasicImage< T > &im, T &mean, T &stddev) |
| template<class S, class T> | |
| void | gradient (const BasicImage< S > &im, BasicImage< T > &out) |
| template<class T, class S> | |
| void | sample (const BasicImage< S > &im, double x, double y, T &result) |
| template<class T, class S> | |
| T | sample (const BasicImage< S > &im, double x, double y) |
| void | sample (const BasicImage< float > &im, double x, double y, float &result) |
| template<class T, class S> | |
| int | transform (const BasicImage< S > &in, BasicImage< T > &out, const TooN::Matrix< 2 > &M, const TooN::Vector< 2 > &inOrig, const TooN::Vector< 2 > &outOrig, const T defaultValue=T()) |
| template<class T> | |
| void | transform (const BasicImage< T > &in, BasicImage< T > &out, const TooN::Matrix< 3 > &Minv) |
| template<class T> | |
| void | flipVertical (Image< T > &in) |
| template<class T> | |
| void | median_filter_3x3 (const SubImage< T > &I, SubImage< T > out) |
| void | median_filter_3x3 (const SubImage< byte > &I, SubImage< byte > out) |
| template<bool Aligned> | |
| __m128i | load_si128 (const void *addr) |
| template<> | |
| __m128i | load_si128< true > (const void *addr) |
| template<class F, class T1, class T2, int A, int M> | |
| void | maybe_aligned_differences (const T1 *a, const T1 *b, T2 *c, size_t count) |
| template<class F, class T1, class T2, int A, int M> | |
| void | maybe_aligned_add_mul_add (const T1 *a, const T1 *b, const T1 &c, T2 *out, size_t count) |
| template<class F, class T1, class T2, int A, int M> | |
| void | maybe_aligned_assign_mul (const T1 *a, const T1 &c, T2 *out, size_t count) |
| template<class F, class R, class T1, int A, int M> | |
| R | maybe_aligned_inner_product (const T1 *a, const T1 *b, size_t count) |
| template<class F, class R, class T1, int A, int M> | |
| R | maybe_aligned_ssd (const T1 *a, const T1 *b, size_t count) |
| template<class F, class T1, class T2, int A, int M> | |
| void | maybe_aligned_square (const T1 *in, T2 *out, size_t count) |
| template<class F, class T1, class T2, int A, int M> | |
| void | maybe_aligned_subtract_square (const T1 *in, T2 *out, size_t count) |
Variables | |
| const ImageRef | fast_pixel_ring [16] |
| cvd_timer | timer |
| 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.
| void CVD::enableFPE | ( | ) | [inline] |
Enable floating point exceptions.
This function may do nothing, depending on the architecture
| 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.
| ptr | The address of the memory to prefetch. | |
| I | The type of prefetch. This depends on the architecture.
|
| 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.
| gl | The pattern from which to generate the strings |
Referenced by open_video_source().
| void CVD::glOrtho | ( | const CVD::ImageRef & | size, | |
| const double | nearPlane = -1.0, |
|||
| const double | farPlane = 1.0 | |||
| ) | [inline] |
Sets up an ortho projection suitable for drawing onto individual pixels of a gl window (or video image.
) glVertex2f(0.0,0.0) will be the top left pixel and glVertex2f(xsize-1.0, ysize-1.0) will be the bottom right pixel. Depth is set from -1 to 1. n.b. You first need to set up the matrix environment yourself, e.g. glMatrixMode(GL_PROJECTION); glLoadIdentity();
| size | ImageRef containing the size of the GL window. |
Definition at line 329 of file gl_helpers.h.
References CVD::ImageRef::x, and CVD::ImageRef::y.
Referenced by glOrtho().
| void CVD::glOrtho | ( | const TooN::Vector< 6 > & | param | ) | [inline] |
Sets up an ortho projection from a simple Vector<6>.
n.b. You first need to set up the matrix environment yourself, e.g. glMatrixMode(GL_PROJECTION); glLoadIdentity();
| param | 6-vector containing the parameters of the projection |
Definition at line 338 of file gl_helpers.h.
References glOrtho().
| void CVD::glFrustum | ( | const TooN::Vector< 6 > & | param | ) | [inline] |
Sets up an ortho projection from a simple Vector<6>.
n.b. You first need to set up the matrix environment yourself, e.g. glMatrixMode(GL_PROJECTION); glLoadIdentity();
| param | 6-vector containing the parameters of the projection |
Definition at line 383 of file gl_helpers.h.
References glFrustum().
| ImageCreationIterator<C> CVD::CreateImagesBegin | ( | const C & | from_me | ) | [inline] |
| ImageCreationIterator<C> CVD::CreateImagesEnd | ( | const C & | , | |
| int | i | |||
| ) | [inline] |
| ImageCreationIterator<C> CVD::CreateImagesEnd | ( | int | i | ) | [inline] |
| ImageType::ImageType CVD::string_to_image_type | ( | const std::string & | name | ) |
Deduce an image type from a filename suffix.
| name | The name of the image file |
Referenced by img_save().
| double CVD::get_time_of_day | ( | ) |
Same as the system call gettimeofday, but returns time since the epoch as a double.
Referenced by CVD::ServerPushJpegBuffer< C >::get_frame().
| 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 81 of file utility.h.
Referenced by transform().
| 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 85 of file utility.h.
Referenced by convolveWithBox(), and zeroBorders().
| void CVD::zeroBorders | ( | BasicImage< T > & | I | ) | [inline] |
Set the one-pixel border (top, bottom, sides) of an image to zero values.
Definition at line 88 of file utility.h.
References CVD::SubImage< T >::size(), CVD::ImageRef::x, CVD::ImageRef::y, and zeroPixels().
Referenced by CVD::Gradient< S, T, 1, 2 >::gradient(), and harrislike_corner_detect().
| 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 101 of file utility.h.
Referenced by convolveWithBox().
| void CVD::add_multiple_of_sum | ( | const A * | a, | |
| const A * | b, | |||
| const float & | 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 110 of file utility.h.
Referenced by convolveGaussian().
| 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 119 of file utility.h.
Referenced by convolveGaussian(), and convolveWithBox().
| double CVD::inner_product | ( | const T * | a, | |
| const T * | b, | |||
| size_t | count | |||
| ) | [inline] |
| double CVD::sum_squared_differences | ( | const T * | a, | |
| const T * | b, | |||
| size_t | count | |||
| ) | [inline] |
| bool CVD::is_aligned | ( | const void * | ptr | ) | [inline] |
Check if the pointer is aligned to the specified byte granularity.
| size_t CVD::steps_to_align | ( | const T * | ptr | ) | [inline] |
| int CVD::transform | ( | const BasicImage< S > & | in, | |
| BasicImage< T > & | out, | |||
| const TooN::Matrix< 2 > & | M, | |||
| const TooN::Vector< 2 > & | inOrig, | |||
| const TooN::Vector< 2 > & | outOrig, | |||
| const T | defaultValue = T() | |||
| ) | [inline] |
a normal member taking two arguments and returning an integer value.
| in | a image containing the information to be extracted. | |
| out | the image to be filled. The whole image out image is filled by the in image. | |
| M | the matrix used to map point in the out matrix to those in the in matrix | |
| inOrig | origin in the in image | |
| outOrig | origin in the out image |
Definition at line 281 of file vision.h.
References sample(), CVD::SubImage< T >::size(), CVD::ImageRef::x, and CVD::ImageRef::y.
| void CVD::flipVertical | ( | Image< T > & | in | ) | [inline] |
flips an image vertically in place.
Definition at line 380 of file vision.h.
References copy(), CVD::SubImage< T >::data(), CVD::SubImage< T >::size(), CVD::ImageRef::x, and CVD::ImageRef::y.
1.5.3