Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

BIAS	This file is part of the BIAS library (Basic ImageAlgorithmS)
AbsoluteOrientation	Computes similarity transformation between 3D point sets
AbsoluteOrientationRANSAC	Robust computation of similarity transformation between two 3D point sets using a RANSAC approach
AffineMapping	Maps image src to image sink with affine transformation
AffineTransf	Last line of an affine transformation in 3d space is always 0 0 0 1 and can therefor be droped from this class for this reason it is necessairy to overload certain operators and functions e.g
AnimationManagerFinder
AppData	This is a chunk of metadata, also see MetaData
Array2D	Generic two dimensional rectangular array holding arbitrary data types
const_iterator	For const_iterator access todo: derive from std::iterator class(es)
iterator	For iterator access todo: derive from std::iterator class(es)
AutoControl	Class for camera movement in autopilot mode
CameraPose
BackwardMapping	Abstract base class to map an image (texture) src to an image sink with an arbitrary continuous function (e.g
BaseException	Generic exception
BaseFactory	Simple factory class designed for usage as a singleton
MapEntry	Struct for storing class details in member map Map_
BIASBlob	Helper class to store blob corners
BIASContour	This class describes a contour using the freemancode
biasGLviewerGLUT
Bilateral	2D bilateral filter
Binomial	Binomial low pass filter class
BinomialCoefficient	Efficient computation of the binomial coefficient
BlobDetectorBase	Purly virtual interface defining class for blob detectors
BlobDetectorBFS	Detects multiple blobs in an image, image has to be black except blocks to detect
BlobDetectorCCA	Does a Connected Component Analyis and gives information about regions in an image, like centroid and bounding boxes
BlobDetectorDOM	Blob detector for 'Difference Of Means'-blobs (so this is not a binary blob detector)
BlobDetectorLevelSet	Evaluates a segementation into fore/back-ground
Bresenham	Scans a line using Bresenhams integer arithmetic algorithm
BresenhamCircle	Scans a circle using Bresenham's integer arithmetic algorithm
BresenhamCircleEighth	Just like BresenhamCircle but only computes 1/8 of the circle
BSplineCurve	This class is intended for drawing of quadratic and cubic regular B-Splines from given control points
BVWXApp
BVWXDnDTarget	Drag and drop files onto application
BVWXMainFrame
BWM_LUT_Entry_Anisotropic	Base class for storing precomputed lookup information for anisotropic interpolation in BackwardMapping
BWM_LUT_Entry_Bicubic	Base class for storing precomputed lookup information for bicubic interpolation in BackwardMapping
BWM_LUT_Entry_Bilinear	Base class for storing precomputed lookup information for bilinear interpolation in BackwardMapping
BWM_LUT_Entry_Nearest	Base class for storing precomputed look-up information in BackwardMapping
BWM_LUT_Entry_Trilinear	Base class for storing precomputed lookup information for trilinear interpolation in BackwardMapping
CalibratedImage	Helper class holding image and associated calibration
CalibratedPyramid	This class takes care of consisiten re-sampling of images and associated ProjectionParameters
Camera	Extends the Image by MetaData support (e.g
CameraData
CameraInfo_s	Stores camera information such as model, vendor, framerates
CameraParam
CameraParameter_s	Stores the camera parameters such as Shutter, Gain, etc
CameraViewController	Base for (interactively) manipulating a (virtual) camera view
CameraViewExternals	Describes external params of a camera view Used e.g
CameraViewFrustum	Describes internal parameter Frustum of an (OpenGL) camera view
CameraViewInternals	Describes internal params of an (OpenGL) camera view
CameraViewport	Describes internal parameter viewport of an (OpenGL) camera view
CamPoseCalib	This classs allows estimation of the internal (except skew) and external camera parameters by an iterative non-linear algorithm from given 2D-3D correspondences
CanCompare	Compile time check for comparabilty of T1 and T2 Found it in Bjarne Stroustrup's FAQ: http://public.research.att.com/~bs/bs_faq2.html
CanCopy	Compile time check for copy compatibilty between T1 and T2 Found it in Bjarne Stroustrup's FAQ: http://public.research.att.com/~bs/bs_faq2.html
CanMultiply	Compile time check if T1 can be multiplied by T2 Found it in Bjarne Stroustrup's FAQ: http://public.research.att.com/~bs/bs_faq2.html
CannyEdge	Canny edge detector
CCAStruct
CensusTransform	3x3 Census Transform of greyscale image
CheckerboardDetector	Detects a checkerboard pattern in an image (typically 7x4 inner corners, asymmetric layout recommended)
CheckerboardDetectorCrossFilter	Detects a checkerboard pattern (typically 7x4 inner corners, asymmetric layout recommended) in an image using a cross shaped image filter
Checksum	Utility class to calculate checksums as CRCs (Cyclic Redundancy Check)
CheckUtils
Cholesky	Calculates the Cholesky decomposition of a matrix with TNT function
clfAlgorithm
clfBuffer	OpenCL Buffer wrapper
clfColorConversion
clfContext	OpenCL Context wrapper
clfCopy
clfException	Clf Exception wrapper, is thrown in case of most clf errors
clfExtractLocalMaxima
clfFilter
clfGauss
clfGradient3x3
clfGradientGauss
clfImage2D	OpenCL Image2D wrapper
clfImage3D	OpenCL Image3D wrapper
clfImageOperator
clfKernelSources
clfMemory
clfProgram	OpenCL Program wrapper
clfRadixSort
clfRecursiveGauss	Recursive approximation of gaussian blur (IIR) opencl implementation of deriche, recursively implementing the gaussian and its derivatives (icip, 1992)
clfResampleImage
clfScaleImage
clfSimpleFilter
clfStructureTensor
clfTrimmedICP
clfTVL1Flow	TVL1 optical flow opencl implementation
clfUnifiedMultilateralFilter
ColFeat	Internal class for feature (with color) passing only
ColorHarris	Detects Harris Features on color images
ColorHistogram	This Class handels Histogram matters on Images
ColorMultiHistogram	This Class handels MultiHistogram matters on Images
ColorSegmentation
ColorSegmentationThreaded	Threaded implementation of ColorSegmentation
ColourGradient	Represents a colour gradient
ColourMap	Applies a colour map to an image
ColourRGB	Interface class used to ease handover in function calls
Condensation	CONDENSATION (CONditional DENSity EstimATION) is a state estimator very similiar to the Kalman Filter, not only for Gaussian-, but also for any multi-modal distribution
CondensHisto	Class for tracking an object in an image
CondensImg	Example class for condensation with a 2-dim state vector
Conic2D	A 3x3 matrix representing a conic (cone/plane intersection)
ConsoleProgress	Visualises the progress of some computation in the console
ConstantRegionDetector	Detects regions with close to zero gradients in images, works on color images only
ContextGLUT	Wrapper to glut-library
ContextPBuffer	Wrapping class implementation for PBuffer class
ContextWX	Context implementation for wxWidgets
ContourBSplineData	Data object which holds all infomations of a B-Spline curve (ContourBSpline); its shared by B-Spline curves with same basis
ContourBSplineShapeMatrix	Data object which holds a shape matrix or regularisation matrix for a b-spline curve; could be shared by some ContourBSpline objects
ContourBSplineType
ContourDetectorBase	Purely virtual interface defining class for contour detectors
ContourDetectorBSpline	Special B-Spline and holds functions to handle fitting
ContourDetectorSimple	Class for calculating the contour of a segmented region
ControlInterface	Defines the common interface used for communication between rendering components
ConvertBayerPattern	Wrapper class to dc1394 bayer conversion class
ConvertHDR	This class handles conversions of HDR images to for example unsigned char
Convolution	Generic convolution class
CoordinateTransform3D	Transforms 3d points between two different coodinate systems, e.g
CornerDetectorBase	Purly virtual interface defining class for corner detectors
CornerDetectorFoerstner	Foerstner corner detector, detects grey value corners in images
CornerDetectorGradient	Base class for all gradient based corner detectors
CornerDetectorHarris	Harris corner detector, detects grey value corners in images
CornerDetectorKLT	Computes the cornerness as the smaller eigenvalue of the structure tensor matrix
CornerDetectorSusan	The Susan corner detector (oxford implementation, see license)
CornerMatcher	Class with various functions to detect corresponding image points
cornerstruct	Used only by Susan corner detector
CorrespondenceMap	Holds dense 2d correspondences (flow field) for an image
COSAC	Complete Sampling Consesus
SolStruct
Cov3Dto2DPoseCertain	Project a 3D covariance matrix into the image plane using the unscented transform assuming that the pose is certain
Covariance3Dto2D	Projection of 3D points with uncertainties covariances into the 2d image plane taking the camera pose uncertainty into account
Covariance3Dto2DHomg	Projection of 3D points with uncertainties covariances into the 2d image plane taking the camera pose uncertainty into account
CovEuler2Quaternion	Conversion of a rotation covariance in Euler-angles representation to a covariance in Quaternion representation using the unscented transform
CovMatrix3x3	Class for 3x3 covariance matrices
CovQuaternion2AxisAngle	Conversion of a rotation covariance in quaternion representation to a covariance in axis-angle representation using the unscented transform
CovTransformPose	Transformations between different representations of poses and their covariances (e.g
CPDiscreteParam
CScommBase	This class CScomm (ClientServer communciation) handles data comunication via TCP/IP for one server and multiple clients
CScommClient	Class for sending/receiving data between clients and servers
CScommData	Helper class for CScommBase
CScommMsg	Helper class for CScommBase
CScommServer	Class for sending/receiving data between clients and serversOnly registered msgs will be accepted at the server side, similar the client will accept only registered msgs from the server too
CSCommWithClientNr	Helper class for CScommBase
CylinderMapping	Functions for spherical undistortion of given images, needs image dimensions, principal point and focal length as input additional to the image data
CylindricalRectification	Class implements rectification by image projection onto a cylinder
CylindricDepthPanorama	Create and represent cylindric depth panorama
CylindricDepthTrackingPanorama
DataPlot	Class to plot data as lines, crosses etc, as gnuplot does, duplicates functionality in class GraphPlotter
DC_GPS
DC_inertial
DC_ptu
Debug
DeInterlace	Deinterlacer filter for images
DensityFilter	Removes areas from an image that have a low density (fill rate)
DerivedFrom	Compile time check if B is (grand)father of T Found it in Bjarne Stroustrup's FAQ: http://public.research.att.com/~bs/bs_faq2.html "Actually, Derived_from doesn't check derivation, but conversion, but that's often a better constaint
Dilation	Dilation operator for binary images (black and white)
DisparityInterpolator
DisplacementMapping	Maps image src to image sink with displacement mapl generated by backwardmapping method
DistanceMeasureControl	Class for distance measurements in 3d model, derives from TrackballControl and SceneBase
DistImgMatAcc
DistortionRendering	Utility class for distortion rendering used by GLProjection
Distribution	Class for calculating mean, variance and possibly other parameters
DistTransform	Class for calculating the distance transform
dndFileTarget	Drag and drop files onto application
DPPanTiltControl	Basic controller interface for Directed Perception Pan Tilt Unit
DPPanTiltControlDialog
DPPanTiltControlExtended	Extended controller interface for Directed Perception Pan Tilt Unit
DrawTextGL	Draw text to OpenGL as 2D bitmap font
DrawTextWx	Writing a text in an bias image usig a wx device context This class uses wxDC and thus it can only be used in wx GUI applications
DShowVideo	Die Klasse ReadAvi ist zentraler Bestandteil der Infrastruktur zum Dekodieren von AVI-Videocontainern. Weitere Bestandteile sind: SampleGrabberCallback
DualQuaternion	Class representing rigid motion by dual quaternions
Edge_s	Struct for easier handling of edges
EightWaySymmetry	Class for transforming any point to first octant
EightWaySymmetryHomg	Direction of line if start is in coordinate origin as given by compass
Ellipse	Ellipse in 2D with dfifferent representations
Ellipsoid3DData	Stores important data for drawing an el4000lipsoid
EMatrix	Class representing an Essential matrix
EParametrization	Slim class bundling essential matrix parameterization and associated covariance matrix
EpipolarLine	A class for representing epipolar lines with useful functions like ScanLine()
Erosion	Erosion operator for binary images (black and white)
EssentialPoint2Line	Computes line and associated covariance matrix given by a point and an essential matrix using unscented transform
EuclideanTransf3D	Euclidean transformation for 3D points
ExampleMixtureOfGaussians
ExampleMixtureOfGaussiansFrame
ExifTag	Helper class containing EXIF Tag info and its's value
ExtendedKalman	Classical ExtendedKalman-filter (EKF)
FatalException	Fatal exception
FFT	Wrapper to the fftw3 library
FFT2D	Wrapper to the fftw3 library adapted for 2D image filtering
FFT2D_free	Wrapper to the fftpack library from netlib (see fftpack/fft.c), implementing the fft (Fast Fourier Transform) for images
FFT2D_Tiles	Wrapper to the fftw3 library, which is supposed to perform the FFT patch- (tile-) wise
FiFoQueue	This class implements a templated standard FiFo-queue for inter process communication (arbitrary number of readers/writers), e.g
FileHandling	Functions to create, check and delete files and to handle file names, such as splitting into directory, filename and suffix
FilterBase	Virtual parent class for API definition of all (future) filters
FilterDialogBase	Base class for all filter dialogs
FilterDialogCannyEdge	Implementation of a CannyEdge filter dialog
FilterDialogGauss	Implementation of a Gauss filter dialog
FilterDialogGradientSobel3x3	Implementation of a GradientSobel3x3 filter dialog
FilterDialogMean	Implementation of a Mean filter dialog
FilterDialogMedian	Implementation of a Median filter dialog
FilterDialogPreviewWindow	A preview window
FilterDialogRescale	Implementation of a Rescale filter dialog
FilterMask	A filter mask (or a kernel) used for convolution
FilterNTo2N	Base class for simple n->2n filter implementations
FilterNTo2NFactory	Creates N-to-2N filters by class name
FilterNTo3N	Base class for simple n->3n filter implementations
FilterNTo3NFactory	Creates N-to-3N filters by class name
FilterNToN	Base class for simple n->n filter implementations
FilterNToNFactory	Creates N-to-N filters by class name
FilterTestPair	Struct holding ground truth data for filter testing\
FitCircleFrame
FlirThermalCameraSerialControl	This class is used for serial communication with the FLIR Tau 320 Thermal camera
FlyControl	Class for camera movement in fly mode
FMatrix	Class representing a Fundamental matrix
FMatrixBase	Describes the epipolar relationship between a point and his mapping on a corresponding epipolar line
FMatrixEstimation	Functions for estimating a fundamental matrix (FMatrix) given a set of 2d-2d correspondences (no outlier checks, not robust !) in two views
ForwardMappingNearestNeighbour
FramebufferSetup
FramebufferSetupPool	Class containing a framebuffer and a map of setups
Gauss	Smoothing with gaussian kernel
GaussHelmert	See Foerstner, 2004, "Uncertainty And Projective Geometry" ! untested !
GaussThreshold	Smoothing with gaussian kernel using a threshold
GenerateGauss	Compute one and two dimensional gauss normal distribution
GenGroundTruth
GenSynthMatches	Class for generating synthetic matches
GenSynthMatchesRig	Generates synthetic matches for cameras in a rig
GenVisiblePoints	Class for generating 3D points visible by a set of cameras
GeometryGL	Reusable Geometry an drawing functions for OpenGL
GlewInitWrapper	To call glewInit() at the right time and only once is not easy in complex applications
glfArrayBufferObject	Wrapper for OpenGL array buffer objects
glfBatch	A batch represents a single Draw call including all parameters (render states)
glfBlendMode	Defines the function that blends rendered geometry with its background
glfBufferObject	Base class of wrapper for OpenGL 3.x buffer objects
glfCubeMap	A cube map texture
glfDepthBufferMode	Defines the usage of the depth buffer
glfElementBuffer	An element buffer contains vertex indices that form primitives
glfException	Exception class used for run-time errors in the OpenGLFramework
glfFBOAttachmentReleaseException	Class is thrown when an release of some FBO attachment point is not possible
glfFormatDB	Helper methods for format conversions in GL and between GL and BIAS
glfFramebufferObject	Framebuffer object
glfMatrix	A 4x4 matrix in native OpenGL format
glfPassiveDepthBufferMode	This class allows to use the currently set viewport in the global opengl state!
glfPassiveRenderMatrix	This class allows to use the currently set RenderMatrix in the global opengl state!
glfPassiveRenderTarget	This class allows to use the currently set RenderTarget in the global opengl state!
glfPassiveViewport	This class allows to use the currently set viewport in the global opengl state!
glfPBuffer_GLX	GLX pbuffer rendering context
glfPBuffer_WGL	WGL pbuffer rendering context
glfRenderbuffer	The renderbuffer
glfRenderingContext	Interface for OpenGL rendering contexts
glfRenderingContext_GLX	Base class for GLX rendering contexts
glfRenderingContext_WGL	Base class for WGL rendering contexts
glfRenderingContextConfig	Configuration for a rendering context
glfRenderTarget	Interface for render targets
glfScreen	Represents the default render target of the current OpenGL context, i.e
glfShader	A GLSL vertex shader or fragment shader, which must be linked in a shader program
glfShaderProgram	A shader program composed of several shaders
glfStencilBufferMode	Defines the usage of the stencil buffer
glfTexture	Base class for textures
glfTexture2D	A 2D texture
glfTexture3D
glfUniformNotFoundException	Class is thrown when a uniform is set but was not set active by the gl compiler
glfVertexBuffer	A vertex buffer contains an array of vertices that can be used for rendering
glfVertexFormat	A vertex format describes the attributes of a vertex
glfViewport	Class for setting viewports
GLProjectionOutputAttachment	Class for extra rendering pass in GLProjection (for now only used in glutGLviewer)
GLProjectionParametersBase	GLPPB encapsulates the opengl rendering interface for the projectionparameter classes
GLProjectionParametersInterface	Abstract interface class to handle changes in rendering parameters by controllers and in rendering contextes
GLProjectionParametersPerspective	Class for rendering with projection parameters of ProjectionParametersPerspective
GlutInitWrapper	To call glutInit() at the right time and only once is not easy in complex applications
GpuImageFilter	Basic image filter on the gpu
GrabMasterThread
GrabSingleThread
GradientGauss	Gradient calculation with separated gauss masks
GradientGaussAsymmetric	Gradient calculation with separated gauss masks
GradientSimple	Simple gradient calculation gx(x,y) = I(x+1,y) - I(x-1,y) gy(x,y) = I(x,y+1) - I(x,y-1)
GradientSobel3x3	Gradient calculation with sobel 3 by 3 masks
GraphPlotter	Use this class to plot data as gnuplot does
GuiBase	Gui is a simple windowing environment..
GuiCV	Gui based on OpenCV is a simple windowing environment..
GuiWX	Simple wxWindow to display an image
GuiWXApp
GuiWXFrame
HessianGauss	Gradient calculation with separated gauss masks
HessianSimple	Simple hessian calculation hxx(x,y) = Hessian in x direction hyy(x,y) = Hessian in y direction
Histo_Entry_Float
HistoFrame	It's a Frame used to have a Histogramm Canvas, which describes a histogramm of current image
Histogram1D	Simple one dimensional histogram computation
Histogram2D
HistogramEqualization	Perfoms a histogram equalization on a grey value image
HistogramImage	Class for easy histogram image generation
HistoImageCanvas	It's a Canvas used to compute Histogram for current image working
HMatrix	3x3 Matrix describing projective transformations between planes
HMatrixBase	Describes a homography
HMatrixEstimation	Estimate 3x3 matrix relating image coordinates with each other, i.e
HomgLine2D	Line l = (a b c)^T is a form of the implicit straight line equation 0 = a*x + b*y + c if homogenized, a^2 + b^2 = 1 beware: (a b) is the vector perpendicular to the line direction therefor b could be interpreted as dx, but then a is equal to -dy
HomgLine3D	Homogenous homogenized line is described by a direction vector PointInf_ (a point at infinity) and a starting point PointFin_ (which is the closest vector from the coordinate origin to the line if the line is not homogenized, it can bve described by any two points
HomgPlane3D	A homogeneous plane (in P^3) All points X on the plane p fulfill p ' * X = 0
HomgPoint1D	Class HomgPoint1D describes a point with 2 degrees of freedom in projective coordinates
HomgPoint2D	Class HomgPoint2D describes a point with 2 degrees of freedom in projective coordinates
HomgPoint2DCov	Class representing the covariance matrix of a homogenous point 2D
HomgPoint3D	Class HomgPoint3D describes a point with 3 degrees of freedom in projective coordinates
HomgPoint3DCov	Class representing the covariance matrix of a homogenous point 3D
HomographyMapping	Maps image src to image sink with homography H (software implementation)
HomographyRectification
ICECallbackInterface	Callback interface for ImageCanvasExtended
ICECCallbackInterface	Callback interface for ImageCanvasCheckerBoardExtract
icppair
icpvecandval
Image	The image template class for specific storage types
Image3DData	Stores datas for a textured plane
ImageAlignment	Inverse Compositional Image Alignment ("Registration")
ImageAttributes	All atribute info and values of e.g. a file
ImageBase	This is the base class for images in BIAS
ImageBlender	Maps images into a common camera and blends them seamlessly
ImageBlenderIncremental	Maps several images into a common mosaic and blends them seamlessly
ImageCalc	Performs pixelwise arithmetic and boolean operations on images
ImageCanvas	Display image in wx application, provides zoom and investigation functionality
ImageCanvasCheckerboardExtract	Functionality for selection of checkerboard patterns
ImageCanvasGLBase	2D image display canvas using OpenGL rendering internally
ImageCanvasRectangularSelection	Functionality for selection of rectangle, point, ..
ImageConvert	Class with static functions for converting all kinds of color formats and storage types
ImageConvertThreaded	Converts images between different color models using multiple threads
ImageDistribution	Maps a set of input images to a given output image so that the space in the output image area is optimally used
ImageDraw	Drawing simple entities into the image like rectangles or lines As all functions are static they have to be called by eg
ImageHeader	Header for sending images over UDP connections
ImageIO	Routines for loading and writing all kinds of image formats
ImageLegendFrame	Frame to display a Image legend, for example in biasviewwx
ImagePackage	An Image Package is multiple .mip images in one file
IPFileInfo
IPImageHeader
ImageSaveThread	This class creates a thread which stores an image in a file if rescale is not zero then the stored image is downsampled by this factor
ImageValueBar	This class represents an image value bar
ImageWarper	This class warpes depth images from one persective to the perspective of another camera
ImgObjGL	Data holder describing OpenGL texture objects in addition to its unique texID
ImgPosition	Interface class used to ease handover in function calls
IndexedFaceSet	Stores data for drawing a indexed face set
IndexLineSetHandler	This class parses a VRML file containing an indexed line set and stores the containing lines
IntegralHistogram	This Class handels Integral Histograms on HSL Images It represents an integral image histogram and offers basic methods on histograms
IntegralImage
Interpolator	This class interpolates a function y=f(t) between given control points (the y-values)
IOUtils	Class grouping together some IO code often used in (small) application, like loading images, parsing their meta data etc
ProgressBar
ProgressIndicator
IselLinearControl	This class controls the Isel Linear Unit
IselLinearControlTwoAxis	This class controls the Isel iMC-S8 Linear Unit (two axis controll)
ItemAndWidget
IteratedExtendedKalman	Iterated Extended Kalman-filter (IEKF)
JointHistogram
JpegHandler	Wrapper for fast libjpeg methods
Kalman	Classical Kalman filter
KMatrix	K describes the mapping from world coordinates (wcs) to pixel coordinates (pcs)
Label	Does a connected component analysis and labels all connected regions
LaguerreSolver	Class encapsulating a laguerre solver for polynomials
LDA	Linear discriminant analysis on a set of classes of vectors LDA is a approach for dimension-reduction of vector-classes while keeping class-separability
LeastSquaresBase	Base class for linear least squares solvers
LeastSquaresLapack	Linear least squares solver based on Lapack routines
LeastSquaresSVD	Linear least squares solver based on singular value decomposition
LEDDetector	This class contains methods to detect (IR)-LED-Spots, with template matching (new search) or in "recycling" mode (search at old positions)
LevenbergMarquardtBase	Base interface for classes using non-linear optimization of a target function using the Levenberg-Marquardt algorithm
LevenbergMarquardtHelper	Simple helper class for Levenberg-Marquardt optimization
Line3DData	Stores data for drawing a line
LinearRegionDetector	Try to detect linear regions (const gradient) in images, experimental code for testing
LocalAffineFrame	Affine transformation of 2D image plane which relates image coordinate system and local affine feature coordinate system
LogFacility
LogPolarMapping	Maps cartesian source coordinates to log-polar sink coordinates
MapFusion
MarchingCubes	Creates a closed mesh from a set of points
MarchingCubesGridCell
MarchingCubesTriangle
MatchDataBase	Class for representing matches, used in GenSynthMatches and biasshowsm
Matrix	Matrix class with arbitrary size, indexing is row major
Matrix2x2	'fixed size' quadratic matrix of dim
Matrix2x3	'fixed size' 2x3 matrix templated over the elemnt-type
Matrix3x2	'fixed size'
Matrix3x3	'fixed size' quadratic matrix of dim
Matrix3x4	'fixed size' rectangular matrix of dim
Matrix4x4	'fixed size' quadratic matrix of dim
Mean	Average mean filter
MeanDoubleRANSACEvaluator	Helper class for implementation of PreemptievRANSAC and COSAC for robust computation of the mean of a vector of doubles
Median	Implements a 2D median filter for images
Median1D	Computes the median and p-quantile of a vector
message_frame_buffer
message_frame_header	Header for sending images over UDP connections
MetaData	This class collects all additional data chunks of type AppData to be written into/read from an image file
MixtureOfGaussians	Class for detecting changes in image sequences
MonteCarloTransform	Monte carlo propagation of uncertainty
Morphology	Base class for Erosion, Dilation, and single Deletion
MSAC	This class does something, but WHAT? Is it the M-Estimator SAmple Consensus ??
MultipleDepthWarp
MutexSingleton	Wrapper for pthread mutex for use with 'automatic' initialization
MyBasicAnimationManager
MySampleGrabberCB
NodeInfo	Struct containing details of a OSG::Node when used in a wxTreeCtrlOpenSGWx
NodeInfoEraseOp
NodeInfoMap
NodeInfoOpBase
NodeInfoOpenSGVisitor	Visitor for traversing the scene graph and applying some operation to the related nodeinfomap
NodeInfoRestoreNameOp
NonFatalException	Non fatal exception
Normalization	Class Normalization Functions, e.g
Nurbs1D	This class implements a NURBS-function with a one dimensional parameter space (A NURBS line)
Nurbs2D	This class implements a NURBS-function with a two dimensional parameter space (A NURBS surface)
Nurbs3D	This class implements a NURBS-function with a three dimensional parameter space (A NURBS volume)
NurbsBase	Base class for NURBS classes
NurbsSurface
OffscreenRendering	Utility class for offscreen rendering used by GLProjection
OnlyRotationControl	Class for camera movement in fixed position, only rotation mode
OpenEXRInterface	Methods for reading and writing OpenEXR files into and from BIAS ImageBase
ChannelData	Used to maintain control of the heap when generating slices
OpenGLCanvas	OpenGL canvases with additinal event handling (JW)
OpenGLCanvasBase	Base class for OpenGL canvases you could derive from to get base functionality (JW)
OpenSceneGraphHelper	Utility class for using OpenSceneGraph
OutputHaze	Exemplary output attachment, creating a bluish haze effect on the rendered output
OutputLensDistortion	Distortion Rendering
OutputUnderwater	Exemplary output attachment, creating a underwater effect
OutputWowDisplay	Exemplary output attachment to create 2D+Depth output for Wow Displays
OutputWowDisplay2	Exemplary output attachment to create 2D+Depth output for Wow Displays
PanelForDoubleValueWx	Helper Class For Parameter Input To Take Floating Point Numbers
PanTiltAutoControl	PanTiltControlInterface
PanTiltAutoControlFactory	Factory to create a PanTiltAutoControl
PanTiltControlFactory	Abstract controller factory used to create all different kinds of PTU controls
PanTiltControlInterface	Abstract control class for control of Directed Perception Pan Tilt Unit
PanTiltManualControl	PanTiltControlInterface
PanTiltManualControlFactory	Factory to create a PanTiltManualControl
PanTiltSoftMotion
Param	This class Param provides generic support for parameters
ParamCallbackInterface	This class provides an interface to be called if parameter changes occured
Parametrization	This class is used for parametrizing F- and H-matrices, generally for optimization purposes
ParamGUI	The main Parameter Gui interface, derived from BIAS::Param and extends this class
ParamGUIDialog	This provides a gui interface for the BIAS::Param class
ParamGUIPanel	This provides a gui interface for the BIAS::Param class
ParamTypeBase	This file holds the definitions of the parameter types used by BIAS::Param
ParamTypeBool
ParamTypeDouble
ParamTypeEnum
ParamTypeInt
ParamTypeString
ParamTypeVecDbl
ParamTypeVecInt
PCA	Principal component analysis on a set of vectors with PCA it is possible to find the most important dimensions of a set of vectors
PerPixelProcessingBase	This class can be used as a simple base class for specialized batches
PixelIterator	Can be used to run along the image border
PlainImageCanvas	Image canvas that does not show zoom frames and redirects mouse click events to its parent
PlainPerPixelProcessing	Class rendering quad and executing a fragment shader
PlanarRectification	Rectification via perspective cameras, removes distortions
PlaneRANSAC	Robust fitting of 3D plane to 3D point set using RANSAC
PlueckerMatrix	Represente a 3d line using a 4x4 Pluecker matrix
PMatrix	Describes a projective 3D -> 2D mapping in homogenous coordinates
PMatrix3DData	Stores important data for drawing a camera
PMatrixBase	Describes a projective 3D -> 2D mapping in homogenous coordinates
PMatrixEstimation	Compute standard P1/P2 from F
PMatrixLinear	This class computes a PMatrix from 2D/3D correspondences with linear methods
PMDImageIO	Save 2D/3D-image-data together with some metadata in a single tiff-datafile
PMDImageMetaData	Store extrinsic and intrinsic camera parameters for Rotation is in axis * angle representation image padding and Metadata
PMDImageProc
PMDWarp	Class can be used to warp sequences of pmd depth images into a second view with different parameters, including a different camera center
Point3DData	Stores data for drawing a point
Polynom	Class for Polynoms of arbitary order
PolynomialSolve	Base class for solving polynomial equations
Pose	Represents 3d pose transformations, parametrized as Euclidean translation and unit quaternion orientation
PoseParametrization	Slim class bundeling pose parametrization and associated covariance matrix
PoseParametrizationCovariance	Class encapsulating the transfromations between different pose parametrizations
Position	Stores valid/nvalid positions in image
PreemptiveRANSAC	Fast RANSAC after David Nister, "Preemptive RANSAC for Live Structure And Motion Estimation", Internation Conference on Computer Vision (ICCV) 2003
SolStruct
Primitives	Helper class for creating primitives
ProgressSemaphore	This class represents a progress counter which multiple processes can use
ProgressSemaphorePool
Projection	This class hides the underlying projection model, like projection matrix, spherical camera, lens distortion
Projection3DData	Stores data for drawing a the extrinisc parameters of a projection
ProjectionError
ProjectionMapping	Maps source pixel to sink pixel of given projections
ProjectionParametersBase	Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as camera pose
ProjectionParametersBufferedRay	This class maps image coords to rays which are buffered for fast lookup
ProjectionParametersCylindric	Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose
ProjectionParametersDynamicLoad	Can load exernally programmed child classes of ProjectionParametersBase
ProjectionParametersFactory
ProjectionParametersGreatCircles	Spherical camera that samples along big circles containig the H vector
ProjectionParametersIO
ProjectionParametersOrthographic	Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose
ProjectionParametersPerspective	Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose
ProjectionParametersPerspectiveDepth	Additional depth calibration parameters for a perspective depth camera to be used for ToF-(PMD) cameras
ProjectionParametersProjective	12 parametric p for completely projective reconstruction scenarios, unknown focal lengths, self calibration, ..
ProjectionParametersSpherical	Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose
ProjectionParametersSphericalFast	Spherical camera that uses polynomial only and should therefore be faster than other spherical camera
ProjectionParametersSphericalSimple	Projection parameters camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose. the parameters phiOffset and thetaOffset are considered to be intrinsic parameters describing the rotation of the principal point the parameters dPhi and dTheta describe the resolution of a pixel in radian per pixel. Distortion is ignored. This class is intended to describe spherical rectification results
ProjectionParametersZoom	Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose
PyramidImage	Class for holding multiple downsampled images
PyramidImageInterface	Interface definition of all pyramid images
Quadric3	Implements a 3D quadric and quadric operations
Quadric3D	A quadric as a 4x4 matrix describing a surface in 3d projective space defined by a quadratic equation, e.g
Quaternion	Class for rotation with axis and angle
Random	Class for producing random numbers from different distributions
RANSAC	Generic abstract base class for RANSAC (RANdom SAmple Consensus) estimators
RANSAC_double	Robust mean computation for double values using RANSAC
RANSACEvaluatorInterface	Interface for computation of solutions and evaluation of measurements
RANSACPreKnowledge	Extension of RANSAC algorithm: user-supplied guesses are evaluated and refined using RANSAC criterions before actually starting the RANSAC algorithm
RectificationBase	Base class for rectification implementations and wrappers
RectificationViaProjectionMappingBase	Base class for rectification implementations that make use of projections to represent rectified state and where the projection-centers in rectified and original state are the same
RedirectStreams	Used to redirect stdout and stderr into files or to silence them
RegionMatcher	Basic functions for CornerMatcher
RenderContextBase	Base for all classes creating interface between GL and "window manager"
RenderModeGL	GLRenderMode describes mode for rendering
Rescale	Down-, Upsampling routines and Resize
RescaleTransfer	Transfer of pixel coordinates for pixel centric reference systems
RMatrix	3D rotation matrix
RMatrixBase	Implements a 3D rotation matrix
ROI	Class for handling different region of interest (ROI) representations..
RotationAveraging	Computes mean of rotations due to different measures
RParametrization	Slim class bundeling rotation matrix parametrization and associated covariance matrix
SameButConst	Compile time check if the ConstType differs from EditableType merely by a const qualifier, i.e
SampleGrabberCallback	Sample grabber callback class for grabbing single frames only
SamplerBinding	Helper to manage the binding of textures to texture units via uniform names
ScaledImageCanvas	Display float images in wx application, provides zoom, scale, shift and investigation functionality
Scanline	Class for scanning a region given by a line and a distance ca
SceneBase	Base class for all scenes
SceneBGImage	Scene that renders a background image behind all other scenes
SceneCheckerBoard2D	The SceneCheckerBoard class allows to draw a 3D checkerboard
SceneCoordinateFrame	Display axes of a local coordinate frame
SceneGL	Simple interface for GL calls
SceneGlutPrimitives	Class for rendering the Glut primitives like teapot, cube, tetrahedron and icosahedron. Mainly used to test rendering without SceneGraph library
SceneGridGround	Display a grid ground for orientation
SceneOpenSceneGraph	Implements narrow access to OpenSceneGraph
ScenePlainOpenSceneGraph	Implements slim openscenegraph scene without extras
ScenePointLight
SceneSimpleQuad	Draws a simple quad
SceneText	Wrapping bias::drawtextgl to BIAS::Scene
SceneTextScreen	Wrapping bias::drawtextgl to BIAS::Scene
SceneTexturedPlane	Display a textured plane
SceneThreeDOutWrapper	Wrapping ThreeDOut OpenGL-functionality
ScreenShotListener	If KEY_F5 is activated screenshot is stored to given basename + screenshot count
SensorData
SeparabelBoxFilter
SeparableBilateralFilter
SerialPortIO	Communication over the serial port, use OpenPort with e.g
SettingsGL	Application controlled OpenGl renderingsettings
ShaderProgramPool	This class represents a set of shader programs one can add and remove shader programs to and from the pool all programs have unique names and can be accessed by the name uniform variables of the shader programs can be set by addressing a program by its name by setting a uniform variable it is checked, if a uniform variable of this type and with this name exists, if not an glfException is thrown before using a shader program call : LinkAll();
SharedPtr	Pointer with reference count and automatic deletion
Tester
SharedPtrBase	Pool ptr to the data and the reference count
ShowCamWxFormat7Frame
ShowCamWxFrame
ShowCamWxVideoSourceFactory
SimilarityTransform	Implements a 3D similarity transformation (rotation, translation, and isometric scaling)
SimpleGLApp	Simple GL application
SimpleGLCanvas	Helper canvas for SimpleGLApp
SimpleGLFrame	Helper frame for SimplaGLApp
SimpleMultiPassFragmentShader	This class collects a number of shaders and textures uniquely identified by their names shader uniforms can be set by addressing the shaders by their names textures a shader reads from and writes to can be spezified by setting input and output textures addressing the textures through their names calling Execute with a vector of shader names as parameter executes all shaders on the gpu in the order given by the shader names vector
Singleton	Simple singleton implementation for multithreaded applications
SMPFSActionInterface	Class allows to add actions different then rendering to the multipass shader execution
SOCP	Wrapper for Second-Order Cone Programming implementation, by Miguel S
SparseArray2D	Generic two dimensional psarsly populated rectangular array holding arbitrary data types
const_iterator	For const_iterator access todo: derive from std::iterator class(es)
iterator	For iterator access todo: derive from std::iterator class(es)
SparseMatrix	Implementation of sparse matrix operations
SphericalCoordinates	Transformation between affine and spherical coordinates
SphericalDepthPanorama	Create and represent spherical depth panorama
SphericalRectification	Class implements rectification by image projection onto a sphere
StandardDeviation	Computes the standard deviation and mean of given values
StatekeeperGL	push and pop GL states on constructor/destructor Helper class pop(save) OpenGL states on construction and push them on destruction automatically
StereoRedGreen	Combine two separate images into one stereo image for red-green glasses
StringUtils	Contains some useful methods for string manipulation
StructureTensor	Basic class for structure tensor calculation
SVD	Computes and holds the singular value decomposition of a rectangular (not necessarily quadratic) Matrix A
SVD3x3	Singular value decomposition for 3x3 matrices
SymmetricMatrix3x3	'fixed size' symmetric quadratic matrix of dim
TemplateSpecializedBatch	This file contains the header for a class template
Tensor3D
Tensor3D3x3x3
TestFilterBase	Helper class for testing individual filters
Text3DData	Stores important data for drawing 3d text
Texture2DPool	Convenience container for managing 2D textures
TextureMapping	Maps source pixel to sink pixel given any TextureTransform
TextureTransform	Class for representing parameterized image warps, such as homography, displacement, ..
TextureTransformAffine	Analytic properties of affine image warp
TextureTransformDisparity	Analytic properties of x-displacement
TextureTransformDisplacement	Analytic properties of 2D image displacement
TextureTransformEuclidian	Analytic properties of Euclidian image warp (rot
TextureTransformHomography	Analytic properties of homography transformation of an image
TextureTransformRotation	Analytic properties of rotational image warp (around some point)
TextureTransformSimilar
TFTensorEstimation	Class TFTensorEstimation
Thinning	Generic Thinning class, uses ethe Rosenfeld algorithm to thin structures in images without erasing them, unlike the erosion filter
ThreeDOut	Unified output of 3D entities via OpenGL or VRML
ThreeDOutOpenSceneGraph	Class for exporting ThreeDOut objects to OSG scene graphs
ThreeDOutParameters	Configuration struct for drawing styles of various 3d objects
TimeMeasure	Class TimeMeasure contains functions for timing real time and cpu time
TimeMeasurement
TimeStamp	Holds system time in milliseconds
TimeStampGen	Generates absolute timestamps with a certain offset from given base-time
Timing	High resolution HW timers JW
TIntersect	Used in function DetermineStartEnd_
TrackballBase	Functionality for editing cameras or transformations in trackball mode. parts of trackballcontroller code have been moved to this base class so they can be used in other trackball classes like trackballTransController
TrackballControl	Class for camera movement in trackball mode
TrackballTransControl	Class for editing scenegraph transform nodes in trackball mode
Tracker	High level tracking class
TrackerBaseAffine
TrackerBaseAffine2	Devel version of antialiased affine tracker
TrackerBaseHomography
TrackerBaseInterface	Base class for the different tracking algorithms, defining the interfaces for the tracking functions
TrackerBaseSimple
TrackerBaseWeighted
TrackerBaseWeighted1D
TrackerSynth	Returns ground truth tracks read from file, for debugging
TransformNode	Interface for transformations edited by a TrackballTransController
TreeDescr	Container for scene root and ptr to nodeinfomap
Triangle	Represents a 2D triangle and allows some computations with it
TriangleMesh	Create and represent a 3D triangle mesh
TriangleMeshSplatRendering	Scene for rendering multiple triangle meshes generated from depth maps
Triangulation	Class for triangulation of 3Dpoints from 2D matches. Covariance matrix (refering to an uncertainty ellipsoid) is computed also
TriangulationMidPoint	Class for triangulation of 3d points from multiple projection rays using the mid-point method
TrifocalTensor
TrifocalTensorBase
TukeyWindow	Multiplies an image with a full image size tukey window
UDPClient	Class for receiving UDP packages
UDPDataConsumer	Interface class for UDP data
UDPServer	UDP server class
UncertaintyTransformBase	Base class for all uncertainty transforms
UnscentedTransform	Uses the unscented transformation to map a normal distribututed random variable using a nonlinear transformation
UnVignette	Unvignette algorithm for images
UUID	Interface class for producing/storing Universally Unique IDentifiers
UUIDsortAscending	Helper class for ascending sort of sequential BIAS::UUID instances
Vector	Class for column vectors with arbitrary size
Vector2	Class Vector2 contains a Vector of dim
Vector3	Class Vector3 contains a Vector of fixed dim
Vector4	Class Vector4 contains a Vector of dim
VectorStatistics	Provides methods to compute statistical values from vector<double>
VideoServer	Class to send images from a camera or disk to a client
VideoShMFeeder	Class to save Images to a Sharerd memory
VideoShMFeederPMD	Class to save Images to a Sharerd memory
VideoSink	VideoSink for writing FFMPEG Videos from images
VideoSink_FFmpeg	Video encoding using FFmpeg library
VideoSource	Defines a common interface to different devices
VideoSource_Centaurus	VideoSource for Centaurus boards and Sony HD cameras
VideoSource_Controller
VideoSource_Controller_Base
VideoSource_Controller_Kinect
VideoSource_Controller_PMD
VideoSource_Controller_PMDZess
VideoSource_Controller_SwissRanger
VideoSource_Controller_XB3
VideoSource_DCAM	This class VideoSource_DCAM implements access to IEEE1394 (Firewire, iLink) cameras following the DCam 2.0 standard protocol
VideoSource_DCAM_BumbleBee
VideoSource_DCAM_XB3	VideoSource PtGrey Bublebee XB3
VideoSource_DcamPMD	Reads PMD-tiffs with depth images and modulation coefficients
VideoSource_Disk	This class simulates a video device by loading images from disk
VideoSource_Disk_Bayer
VideoSource_DiskPMD	Reads PMD-tiffs with depth images and modulation coefficients
VideoSource_DiskZessPMD	Reads images from three image lists with 2d images, depth images and modulation coefficients
VideoSource_DSHOW	This class extends VideoSource for the use of DirectShow devices you need Microsoft Windows SDK version 6.1 and Microsoft DirectX 9 SDK (November 2008)
CameraControl
VideoSource_DV	This class extends VideoSource for the use of IEEE1394-connected DV-camcorders
VideoSource_DV2	This class extends VideoSource for the use of IEEE1394-connected DV-camcorders. The low-level driver in DV2 is dv1394.o using DMA transfers. Create device: /dev/dv1394 171 32+i
VideoSource_FFmpeg	Simple video decoding of video files using FFmpeg library
VideoSource_FFMPEGVideo	Class for extracting frames from video files using FFMpeg, analog to class DShowVideo
VideoSource_Kinect	Use Kinect with the libfreenect drivers just like the ToF Cameras
VideoSource_Kinect2	Use the Kinect2 class to grab images from the Microsoft Kinect2
VideoSource_Kinect2Net	Provides remote access to a Microsoft Kinect2 camera
VideoSource_Kinect_Base	Use Kinect just like the ToF Cameras
VideoSource_Kinect_Callback	Implementing FreenectDevice Interface, this class is used internally by VideoSource_Kinect - do not use directly
VideoSource_MDcam	VideoSource_MDcam simplifies acces to more then one DCam. It suports multiple IEEE1394-adapters, extern synchronization via parallel port and networked capture cluster
VideoSource_Net	This class implements a video streaming client using TCP
VideoSource_OpenNI	Use OpenNI just like the ToF Cameras
VideoSource_PMD	Support for CamCube usb cam
VideoSource_PMDZess	Zess PMD camera driver interface TODO: include support for normal images (2DImg_), not supported by prototype
VideoSource_Shm	This class implements a video streaming client using shared memory to receive images from another application
ShmImageHeader
VideoSource_ShmPMD	This class implements a video streaming client using shared memory to receive images from another application. It also transfers Depth and Amplitude data coming from a PMD camera
VideoSource_Stereo	Bundles two video sources for stereo
VideoSource_SwissRanger	Support for SwissRanger usb cam
VideoSource_uEye	This class extends VideoSource for the use of IDS uEye devices
CuEye	Defines a structure describing a uEye camera instance
UeyeGrabThread	Defines a thread for asynchronous uEye camera capturing
VideoSource_V4L	This class extends VideoSource for the use of Video4Linux supported devices like framegrabber, USB cameras
VideoSourceCapabilities	Checks for VideoSource capabilities
InputDescriptor
ResolutionEntry
VideoStream	To allow capturing of camera image to disk efficiently, (avoid multiple memcopy operations), this class defines an interface to file containing one header and multiple images
VSHeader
VSImageHeader
VideoTransmitter	Class to send images to a client uses TCP or UDPServer,
View	A view is a rectangular part of a render context in which a set of scenes is rendered using a GLProjection
ViscaControl	For use with Sony PanTilt Cameras, also compatible with WISKA PanTilt Cameras
WeightedSigmaPoint
WoWDisplayShader
WrapBias2Ipl	Wrapper around a BIAS image to be used as an OpenCv IPlimage with shared data area
wxChoiceWithMemory
wxMatrixPanel	Panel for displaying and editing matrices
wxMessageDialogCheckbox
wxProjectionDialog	Dialog containing a wxProjectionPanel
wxProjectionPanel	Panel for displaying and editing projections
WxToAsciiArray	Class for converting an array of wxStrings to an array of non-const ASCII strings
wxVectorPanel	Panel for displaying and editing vectors
wxViscaControlFrame	Implementing wxViscaControlFrameInterface
wxViscaControlFrameInterface	Class wxViscaControlFrameInterface
wxViscaControlPanel	Implementing wxViscaControlPanelInterface
wxViscaControlPanelButtons	Implementing wxViscaControlPanelButtonsInterface
wxViscaControlPanelButtonsInterface	Class wxViscaControlPanelButtonsInterface
wxViscaControlPanelInterface	Class wxViscaControlPanelInterface
XMLBase	Base class with interface for xml output
XMLIO	Wrapper class for reading and writing XML files based on the XML library libxml2
ZoomFrame	Used by ImageCanvas and ScaledImageCanvas, should not be used directly
ZoomImageCanvas
osg
ref_ptr
TNT
const_Region1D
const_Region2D
Fortran_Matrix
Fortran_Sparse_Col_Matrix
Fortran_Sparse_Vector
Index1D
LowerTriangularView
Matrix
Region1D
Region2D
stopwatch
Transpose_View
UnitLowerTriangularView
UnitUpperTriangularView
UpperTriangularView
Vector
Vector_Adaptor
_cl_buffer_region
_cl_image_format
alist	Rewind, backspace, endfile
BIASOpenGLViewerFrame	Class BIASOpenGLViewerFrame
cilist
cl_char16
cl_char2
cl_char4
cl_char8
cl_double16
cl_double2
cl_double4
cl_double8
cl_float16
cl_float2
cl_float4
cl_float8
cl_int16
cl_int2
cl_int4
cl_int8
cl_long16
cl_long2
cl_long4
cl_long8
cl_short16
cl_short2
cl_short4
cl_short8
cl_uchar16
cl_uchar2
cl_uchar4
cl_uchar8
cl_uint16
cl_uint2
cl_uint4
cl_uint8
cl_ulong16
cl_ulong2
cl_ulong4
cl_ulong8
cl_ushort16
cl_ushort2
cl_ushort4
cl_ushort8
clfDeviceInfo
cllist
complex
CuEye
doublecomplex
Histogramm_float_Entry	Base class for storing computed histogramm information in HistoCanvas
icilist
InategralImage	Class to create a summed area table (aka integral image)
inlist
Multitype
Namelist
olist
option
RGBAd	Class RGBAd is asynonym for a Vector4 of correct type
RGBAf	Class RGBAf is asynonym for a Vector4 of correct type
RGBAuc	Class RGBAuc is asynonym for a Vector4 of corerct type
RGBd	Class RGBAd is a synonym for a Vector of correct type
RGBf	Class RGBAf is a synonym for a Vector3 of correct type
RGBuc	Class RGBuc is a synonym for a Vector3 of correct type
ShowCamWxApp
ShowCamWxFrame	This class is the main frame of the ShowCamWx Application
TemplateInit	Helper class for the Nurbs class set
Vardesc
VideoSource_DCAM_BUMBLEBEE	VideoSource PtGrey Bumblebee cameras
wxScrolledWindow
wxTauControlFrame	Implementing wxTauControlFrameInterface
wxTauControlFrameInterface	Class wxTauControlFrameInterface
wxTopLevelWindow
wxTopLevelWindowNative
wxTwoFilesInputDialog	Implementing wxTwoFilesInputDialogInterface
wxTwoFilesInputDialogInterface	Class wxTwoFilesInputDialogInterface
wxVideoSettingsDialog	Implementing wxVideoSettingsDialogBase
wxVideoSettingsDialogBase	Class wxVideoSettingsDialogBase
wxWindow
xvimage