Basic Image AlgorithmS Library
2.8.0

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/background 
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 BSplines 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 lookup 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 resampling 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 nonlinear algorithm from given 2D3D 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 multimodal distribution 
CondensHisto  Class for tracking an object in an image 
CondensImg  Example class for condensation with a 2dim 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 glutlibrary 
ContextPBuffer  Wrapping class implementation for PBuffer class 
ContextWX  Context implementation for wxWidgets 
ContourBSplineData  Data object which holds all infomations of a BSpline curve (ContourBSpline); its shared by BSpline curves with same basis 
ContourBSplineShapeMatrix  Data object which holds a shape matrix or regularisation matrix for a bspline curve; could be shared by some ContourBSpline objects 
ContourBSplineType  
ContourDetectorBase  Purely virtual interface defining class for contour detectors 
ContourDetectorBSpline  Special BSpline 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 Eulerangles 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 axisangle 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 AVIVideocontainern. 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 ExtendedKalmanfilter (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 FiFoqueue 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 Nto2N filters by class name 
FilterNTo3N  Base class for simple n>3n filter implementations 
FilterNTo3NFactory  Creates Nto3N filters by class name 
FilterNToN  Base class for simple n>n filter implementations 
FilterNToNFactory  Creates NtoN 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 2d2d 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 runtime 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(x1,y) gy(x,y) = I(x,y+1)  I(x,y1) 
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 yvalues) 
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 iMCS8 Linear Unit (two axis controll) 
ItemAndWidget  
IteratedExtendedKalman  Iterated Extended Kalmanfilter (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 dimensionreduction of vectorclasses while keeping classseparability 
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)LEDSpots, with template matching (new search) or in "recycling" mode (search at old positions) 
LevenbergMarquardtBase  Base interface for classes using nonlinear optimization of a target function using the LevenbergMarquardt algorithm 
LevenbergMarquardtHelper  Simple helper class for LevenbergMarquardt 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 logpolar 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 elemnttype 
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 pquantile 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 MEstimator 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 NURBSfunction with a one dimensional parameter space (A NURBS line) 
Nurbs2D  This class implements a NURBSfunction with a two dimensional parameter space (A NURBS surface) 
Nurbs3D  This class implements a NURBSfunction 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 Hmatrices, 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/3Dimagedata together with some metadata in a single tiffdatafile 
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: usersupplied 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 projectioncenters 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 OpenGLfunctionality 
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 SecondOrder 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 redgreen 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 xdisplacement 
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 basetime 
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 midpoint 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 PMDtiffs 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 PMDtiffs 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 IEEE1394connected DVcamcorders 
VideoSource_DV2  This class extends VideoSource for the use of IEEE1394connected DVcamcorders. The lowlevel 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 IEEE1394adapters, 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 nonconst 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 