|
CVD 0.8
|
All classes and functions are within the CVD namespace. More...
Namespaces | |
| namespace | ColourSpace |
| namespace | Exceptions |
| namespace | ImageError |
| namespace | Interpolate |
| namespace | ImageType |
| namespace | Morphology |
| namespace | VideoBufferFlags |
| namespace | VFB |
| namespace | SGI |
| namespace | DC |
| namespace | DV3 |
| namespace | V4L1 |
Classes | |
| class | Argb |
| A colour consisting of red, green, blue and alpha components. More... | |
| class | Bgrx |
| A colour consisting of red, green, blue and dummy components, in the order bgr dummy in memory. More... | |
| class | Brezenham |
| Class to implement the Bresenham line-drawing algorithm. More... | |
| class | Brezenham8 |
| Class to implement the Bresenham line-drawing algorithm. More... | |
| struct | IsConvertible< yuv411, Rgb< byte > > |
| struct | IsConvertible< yuv411, byte > |
| struct | IsConvertible< yuv422, Rgb< byte > > |
| struct | IsConvertible< yuv422, byte > |
| struct | IsConvertible< bayer_bggr, byte > |
| struct | IsConvertible< bayer_grbg, byte > |
| struct | IsConvertible< bayer_gbrg, byte > |
| struct | IsConvertible< bayer_rggb, byte > |
| struct | IsConvertible< bayer_bggr, Rgb< byte > > |
| struct | IsConvertible< bayer_grbg, Rgb< byte > > |
| struct | IsConvertible< bayer_gbrg, Rgb< byte > > |
| struct | IsConvertible< bayer_rggb, Rgb< byte > > |
| struct | IsConvertible< bayer_bggr16, unsigned short > |
| struct | IsConvertible< bayer_grbg16, unsigned short > |
| struct | IsConvertible< bayer_gbrg16, unsigned short > |
| struct | IsConvertible< bayer_rggb16, unsigned short > |
| struct | IsConvertible< bayer_bggr16, Rgb< unsigned short > > |
| struct | IsConvertible< bayer_grbg16, Rgb< unsigned short > > |
| struct | IsConvertible< bayer_gbrg16, Rgb< unsigned short > > |
| struct | IsConvertible< bayer_rggb16, Rgb< unsigned short > > |
| struct | IsConvertible< bayer_bggr16be, unsigned short > |
| struct | IsConvertible< bayer_grbg16be, unsigned short > |
| struct | IsConvertible< bayer_gbrg16be, unsigned short > |
| struct | IsConvertible< bayer_rggb16be, unsigned short > |
| struct | IsConvertible< bayer_bggr16be, Rgb< unsigned short > > |
| struct | IsConvertible< bayer_grbg16be, Rgb< unsigned short > > |
| struct | IsConvertible< bayer_gbrg16be, Rgb< unsigned short > > |
| struct | IsConvertible< bayer_rggb16be, Rgb< unsigned short > > |
| 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_bggr |
| Bayer datatype representing the colour filter pattern BGGR. More... | |
| struct | bayer_gbrg |
| Bayer datatype representing the colour filter pattern GBRG. More... | |
| struct | bayer_grbg |
| Bayer datatype representing the colour filter pattern GRBG. More... | |
| struct | bayer_rggb |
| Bayer datatype representing the colour filter pattern RGGB. More... | |
| struct | bayer_bggr16 |
| 16 bit Bayer datatype representing the colour filter pattern BGGR More... | |
| struct | bayer_gbrg16 |
| 16bit Bayer datatype representing the colour filter pattern GBRG More... | |
| struct | bayer_grbg16 |
| 16bit Bayer datatype representing the colour filter pattern GRBG More... | |
| struct | bayer_rggb16 |
| 16bit Bayer datatype representing the colour filter pattern RGGB More... | |
| struct | bayer_bggr16be |
| 16 bit big endian Bayer datatype representing the colour filter pattern BGGR More... | |
| struct | bayer_gbrg16be |
| 16bit big endian Bayer datatype representing the colour filter pattern GBRG More... | |
| struct | bayer_grbg16be |
| 16bit big endian Bayer datatype representing the colour filter pattern GRBG More... | |
| struct | bayer_rggb16be |
| 16bit big endian Bayer datatype representing the colour filter pattern RGGB 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...u...v) data. 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 > |
| struct | DeinterlaceBufferFields |
| A decorator class which wraps a VideoBuffer to return fields instead of the original frames (see also DeinterlaceFrame). More... | |
| class | DeinterlaceBuffer |
| 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... | |
| struct | ESMResult |
| Result class storing some information about the optimization. More... | |
| class | Homography |
| a generic implementation for 2D homography-based transformations parameterized by a 3x3 matrix with determinant == 1. More... | |
| class | HomographyPrefix |
| This class provides a generic 2D homography transformation, but also applies a fixed transformation on the input pixel locations. More... | |
| class | CameraRotation |
| a special implementation for 2D homography-based transformations described as a camera rotating around its centre. More... | |
| class | StaticAppearance |
| Basic appearance model implementing no change in the image. More... | |
| class | OffsetAppearance |
| Simple appearance model that assumes a constant offset in the intensities of the image vs. More... | |
| class | BlurAppearance |
| Blur appearance model that assumes that the input image was subject to blur. More... | |
| class | ESMEstimator |
| The main class for the ESM module. More... | |
| class | RotationEstimator |
| a specialization of ESMEstimator for pure camera rotation only. 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 | 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 |
| struct | ConvertImage< T, T, Pixel::GenericConversion< T, T >, 1 > |
| struct | ConvertImage< Rgb< byte >, byte, Pixel::CIE< Rgb< byte >, byte >, 1 > |
| struct | IsConvertible |
| Can two types be converted with CVD::convert_image? More... | |
| struct | PixelByPixelConvertible |
| Can individual pixels of two types be converted with ConvertPixels::convert()? E.g. More... | |
| struct | PixelByPixelConvertible< InOut, InOut > |
| Identity conversion by memcpy is always supported. More... | |
| 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 |
| An (x,y) image co-ordinate. More... | |
| 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 | NoCopy |
| Conveniently block the copy constructor and assignment operator of subclasses. 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 |
| A 32-bit colour. More... | |
| 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... | |
| class | 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... | |
| class | SimpleTimer |
| Provides a simple timer class which uses cvd_timer internally. More... | |
| struct | ZeroPixel |
| struct | ZeroPixel< T, true > |
| struct | ZeroPixels |
| struct | ZeroPixels< T, true > |
| struct | SumSquaredDifferences |
| struct | VideoBufferType |
| The semsntics of the videobuffer. See VideoFrame::type() More... | |
| class | RawVideoBuffer |
| Base class which provides untyped access to video grabber objects. More... | |
| class | VideoBuffer |
| Base class for objects which provide a typed video stream. More... | |
| class | VideoBufferWithData |
| Certain video buffers, especially the decorator classes, and buffers such as ServerPushJpegBuffer have additional data with the same lifetime as the buffer. 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 | makeJPEGStream |
| struct | makeJPEGStream< T, false > |
| struct | makeDeinterlaceBuffer |
| struct | makeDeinterlaceBuffer< T, 0 > |
| struct | MakeConverter |
| struct | MakeConverter< Out, In, false > |
| struct | MakeConverter< T, T, true > |
| struct | makeDiskBuffer2 |
| struct | makeDiskBuffer2< T, false > |
| 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 > |
| struct | V4L2_Traits< CVD::YC > |
| 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 |
Typedefs | |
| typedef Brezenham | Bresenham |
| typedef Brezenham8 | Bresenham8 |
| typedef unsigned char | byte |
| typedef bayer_bggr | bayer |
| 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, FILL = 0, OUTLINE = 1, NICE = 2 } |
| enum | TEXT_STYLE { FILL = 0, OUTLINE = 1, NICE = 2, 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_bggr > &from, BasicImage< byte > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_grbg > &from, BasicImage< byte > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_gbrg > &from, BasicImage< byte > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_rggb > &from, BasicImage< byte > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_bggr > &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_gbrg > &from, BasicImage< Rgb< byte > > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_rggb > &from, BasicImage< Rgb< byte > > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_bggr16 > &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_gbrg16 > &from, BasicImage< unsigned short > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_rggb16 > &from, BasicImage< unsigned short > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_bggr16 > &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_gbrg16 > &from, BasicImage< Rgb< unsigned short > > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_rggb16 > &from, BasicImage< Rgb< unsigned short > > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_bggr16be > &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_gbrg16be > &from, BasicImage< unsigned short > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_rggb16be > &from, BasicImage< unsigned short > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_bggr16be > &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_gbrg16be > &from, BasicImage< Rgb< unsigned short > > &to) |
| template<> | |
| void | convert_image (const BasicImage< bayer_rggb16be > &from, BasicImage< Rgb< unsigned short > > &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 , int A, int B, int C, int D> | |
| 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 (SubImage< T > &im, double x1, double y1, double x2, double y2, 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, const TooN::Vector< 2 > &p1, const TooN::Vector< 2 > &p2, const T &c) |
| template<class T > | |
| void | drawShape (SubImage< T > &im, const ImageRef &offset, const std::vector< ImageRef > &points, const T &c) |
| template<class T , class PointIterator > | |
| void | drawShape (Image< T > &im, const ImageRef &offset, PointIterator begin, PointIterator end, const T &c) |
| 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) |
| std::vector< ImageRef > | getCircle (int radius) |
| std::vector< ImageRef > | getDisc (float radius) |
| std::vector< ImageRef > | getSolidEllipse (float r1, float r2, float theta) |
| 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) |
| std::ostream & | operator<< (std::ostream &out, const ESMResult &r) |
| template<typename P > | |
| TooN::Matrix< 3, 3, P > | scaleHomography (const TooN::Matrix< 3, 3, P > &H, const P &f) |
| template<int PARAMS> | |
| std::ostream & | operator<< (std::ostream &out, const Homography< PARAMS > &t) |
| std::ostream & | operator<< (std::ostream &out, const StaticAppearance &t) |
| std::ostream & | operator<< (std::ostream &out, const OffsetAppearance &t) |
| std::ostream & | operator<< (std::ostream &out, const BlurAppearance &t) |
| 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) |
| void | glRect (const ImageRef &p, const ImageRef &q) |
| 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 | glRect (const TooN::Vector< 2 > &p, const TooN::Vector< 2 > &q) |
| 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 P , class A > | |
| void | glMultMatrix (const TooN::Matrix< N, N, P, A > &m) |
| template<class P , class A > | |
| void | glMultMatrix (const TooN::Matrix< 3, 3, P, A > &m) |
| template<class P , class A > | |
| void | glMultMatrix (const TooN::Matrix< 2, 2, P, A > &m) |
| template<typename P > | |
| void | glMultMatrix (const TooN::SO3< P > &so3) |
| template<typename P > | |
| void | glMultMatrix (const TooN::SE3< P > &se3) |
| template<typename P > | |
| void | glMultMatrix (const TooN::SO2< P > &so2) |
| template<typename P > | |
| void | glMultMatrix (const TooN::SE2< P > &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<typename P , typename A > | |
| void | glFrustum (const TooN::Vector< 4, P, A > ¶ms, double width, double height, double nearPlane=0.1, double farPlane=100) |
| template<class CAMERA > | |
| void | glFrustum (const CAMERA &camera, double width, double height, double nearPlane=0.1, double farPlane=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 P1 , class P2 > | |
| void | glLine (const P1 &x1, const P2 &x2) |
| 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<int N, typename P , typename A > | |
| void | glTranslate (const TooN::Vector< N, P, A > &v) |
| template<typename P , typename A > | |
| void | glTranslate (const TooN::Vector< 2, P, A > &v) |
| template<typename P , typename A > | |
| void | glTranslate (const TooN::Vector< 1, P, A > &v) |
| template<typename P > | |
| void | glOrtho (const CVD::ImageRef &size, const P nearPlane=-1.0, const P farPlane=1.0) |
| template<typename P , typename A > | |
| void | glOrtho (const TooN::Vector< 6, P, A > ¶m) |
| template<typename P , typename A > | |
| void | glFrustum (const TooN::Vector< 4, P, A > ¶ms, const float width, const float height, const float nearPlane=0.1, const float farPlane=100) |
| template<class CAMERA > | |
| void | glFrustum (const CAMERA &camera, const float width, const float height, const float nearPlane=0.1, const float farPlane=100) |
| template<typename P , typename A > | |
| void | glFrustum (const TooN::Vector< 6, P, A > ¶m) |
| template<typename P , typename A > | |
| void | glColor (const TooN::Vector< 3, P, A > &v) |
| template<typename P , typename A > | |
| void | glColor (const TooN::Vector< 4, P, A > &v) |
| template<typename P , typename A > | |
| void | glClearColor (const TooN::Vector< 4, P, A > &v) |
| template<typename P , typename A > | |
| void | glClearColor (const TooN::Vector< 3, P, A > &v) |
| template<typename P , typename A > | |
| void | glColor (const TooN::Vector<-1, P, A > &v) |
| template<class It > | |
| void | haar1D (It from, It to) |
| template<class It > | |
| void | inv_haar1D (It from, It to) |
| template<class It > | |
| void | haar1D (It from, int size) |
| template<class It > | |
| void | inv_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 SubImage< 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 SubImage< 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 SubImage< 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 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 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 D > | |
| Image< D > | convert_image (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, 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, const std::string &name, const std::map< std::string, Parameter<> > &p=std::map< std::string, Parameter<> >()) |
| 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) |
| template<class Accumulator , class T > | |
| void | morphology (const SubImage< T > &in, const std::vector< ImageRef > &selem, const Accumulator &a_, SubImage< T > &out) |
| Image< T > | morphology (const SubImage< T > &in, const std::vector< ImageRef > &selem, const Accumulator &a_) |
| 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 () |
| long long | get_time_of_day_ns () |
| 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 T > | |
| void | fillBorders (SubImage< T > &im, const T pix, int w=1) |
| template<class A , class B > | |
| void | differences (const A *a, const A *b, B *diff, 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) |
| 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 double &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) |
| ImageRef | ir_rescale_rounded (const ImageRef &v, double rescaling_factor) |
| std::ostream & | operator<< (std::ostream &out, const VideoSource &vs) |
| void | parse (std::istream &in, VideoSource &vs) |
| template<class T > | |
| VideoBuffer< T > * | open_video_source (const std::string &src) |
| void | get_jpegstream_options (const VideoSource &vs, int &fps) |
| void | get_deinterlace_options (const VideoSource &vs, DeinterlaceBufferFields::Fields &fields, bool &) |
| void | get_colourspace_options (const VideoSource &vs, std::string &from) |
| template<class Out , class In > | |
| VideoBuffer< Out > * | makeConvertBufferBit (const std::string &r) |
| template<class T > | |
| VideoBuffer< T > * | makeColourspaceBuffer (const std::string &c, const std::string &r) |
| 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 &) |
| template<> | |
| VideoBuffer< byte > * | makeV4L1Buffer (const std::string &dev, const ImageRef &size) |
| void | get_v4l1_options (const VideoSource &vs, ImageRef &size) |
| template<class T > | |
| VideoBuffer< T > * | makeV4LBuffer (const std::string &, const ImageRef &, int, bool, bool) |
| template<> | |
| VideoBuffer< byte > * | 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) |
| template<> | |
| VideoBuffer< byte > * | makeVideoFileBuffer (const std::string &file, VideoBufferFlags::OnEndOfBuffer eob) |
| void | get_file_options (const VideoSource &vs, int &ra_frames, VideoBufferFlags::OnEndOfBuffer &eob) |
| template<class T > | |
| VideoBuffer< T > * | makeDVBuffer2 (int, ImageRef, float, ImageRef, bool, bool, int) |
| template<> | |
| VideoBuffer< byte > * | makeDVBuffer2 (int cam, ImageRef size, float fps, ImageRef offset, bool verbose, bool bus_reset, int format7_mode) |
| void | get_dc1394_options (const VideoSource &vs, ImageRef &size, float &fps, ImageRef &offset, bool &verbose, bool &bus_reset, int &format7_mode) |
| template<class T > | |
| VideoBuffer< T > * | makeQTBuffer (const ImageRef &, int, bool, bool) |
| template<> | |
| VideoBuffer< vuy422 > * | makeQTBuffer (const ImageRef &size, int input, bool showsettings, bool verbose) |
| void | get_qt_options (const VideoSource &vs, ImageRef &size, bool &showsettings, bool &verbose) |
| template<class T > | |
| VideoBuffer< T > * | open_video_source (const VideoSource &vs) |
| template<class T > | |
| VideoBuffer< T > * | open_video_source (std::istream &in) |
| template<class C > | |
| void | twoThirdsSample (const SubImage< C > &in, SubImage< C > &out) |
| void | twoThirdsSample (const SubImage< byte > &in, SubImage< byte > &out) |
| template<class C > | |
| Image< C > | twoThirdsSample (const SubImage< C > &from) |
| 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 , typename Precision > | |
| void | sample (const SubImage< S > &im, Precision x, Precision y, T &result) |
| template<class T , class S , typename Precision > | |
| T | sample (const SubImage< S > &im, Precision x, Precision y) |
| void | sample (const SubImage< float > &im, double x, double y, float &result) |
| template<class T > | |
| void | flipVertical (Image< T > &in) |
| template<class T > | |
| void | flipHorizontal (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 |
All classes and functions are within the CVD namespace.
| 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 |
| 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 351 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 360 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 405 of file gl_helpers.h.
References glFrustum().
| void CVD::glOrtho | ( | const CVD::ImageRef & | size, |
| const P | nearPlane = -1.0, |
||
| const P | 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 176 of file gles1_helpers.h.
References CVD::ImageRef::x, and CVD::ImageRef::y.
| void CVD::glOrtho | ( | const TooN::Vector< 6, P, A > & | 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 185 of file gles1_helpers.h.
| void CVD::glFrustum | ( | const TooN::Vector< 6, P, A > & | 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 230 of file gles1_helpers.h.
| 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] |
| Image<D> CVD::convert_image | ( | const SubImage< C > & | from | ) |
Convert an image from one type to another using the default.
| 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.
References convert_image(), and CVD::SubImage< T >::size().
| 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 |
| double CVD::get_time_of_day | ( | ) |
Same as the system call gettimeofday, but returns seconds since the epoch as a double.
Referenced by CVD::ServerPushJpegBuffer< C >::get_frame().
| void CVD::fillBorders | ( | SubImage< T > & | im, |
| const T | pix, | ||
| int | w = 1 |
||
| ) |
Fill image borders.
| im | Image fo fill borders in |
| pix | Fill value |
| w | border width |
Definition at line 107 of file utility.h.
References CVD::SubImage< T >::size(), CVD::ImageRef::x, and CVD::ImageRef::y.
1.7.4