| _FilterBorders | |
| BIAS::AbsoluteOrientation | Computes translation and rotation between 3D point sets |
| BIAS::AbsoluteOrientationRANSAC | Robust computation of translation and rotation between 3D point sets using a RANSAC approach |
| AffineBackTransform | Transform 6D uncertainty into 2d image uncertainty in same image |
| BIAS::AffineMapping< InputStorageType, OutputStorageType > | Maps image src to image sink with affine transformation |
| BIAS::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 |
| AffineTransform | Transform 6D uncertainty into 2d image uncertainty in other image |
| alist | |
| BIAS::AppData | This is a chunk of metadata, also see MetaData |
| BIAS::Array2D< T > | Generic two dimensional rectangular array holding arbitrary data types |
| BIAS::Array2D< T >::const_iterator | For const_iterator access todo: derive from std::iterator class(es) |
| BIAS::Array2D< T >::iterator | For iterator access todo: derive from std::iterator class(es) |
| BIAS::AutoControl | |
| BIAS::AutoControlFactory | |
| BIAS::BackwardMapping< InputStorageType, OutputStorageType > | Abstract base class to map an image (texture) src to an image sink with an arbitrary continuous function (e.g |
| Base | |
| BIAS::BaseException | Generic exception |
| BIAS::BIAS_HAVE_XML2 | |
| biasadd | Tool for adding two images pixelwise |
| biasaddchannel | Tool for combining images channel-wise |
| biasapplybayer | Converts various Bayer pattern images to RGB images |
| biasaverage | Load image given by the command line, assign a uuid and write back |
| BIAS::BIASBlob | Helper struct to store blob corners |
| biascalibratecamera | The program reads the images from disk,detects chessboard of given known dimension, and computes internal calibration parameters (and extrinsics for this purpose, too) |
| BIAS::BIASContour | ContourPixel: all pixels contained in the contour |
| biasconvert | Convert input image format to output image format |
| BiasDetectUnvignetteApp | |
| biasdiff | Tool for computing intensity difference of images |
| biasdiv | Tool for computing pixelwise division of two images |
| biasextract | Extract header data from image files: uid, time stamp orientation, KMatrix from EXIF data, |
| biasextractcheckerboard | The tool tries to find checkerboards in the input images finds corners also in fisheye distorted images andwrites these to the Matlab file 'Filename.m' |
| biasextractcheckerboardWX | The tool tries to find checkerboards in the input images and writes these to the Matlab file 'Filename.m' |
| biasfilter | Tool to filter an image with Mean, Gauss, Median or rescale |
| biashistogram | Detects a color histogram and writes to file hist.txt |
| biasinsert | Program for inserting an image into another |
| biasmerge | Merge a projection matrix and an image, write header data to image |
| biaspackage | Unpacks image packages written by ShowCamWx |
| biasproject | Rotate/rectify/reproject images to (rotated) images (of different camera type) |
| biasprojection | Read images and pmatrices, projects 3d points and cuts out region |
| biasrectify | Tool for rectifying images |
| biasrescale | Rescales images by given ratio (including projection parameters) |
| biasrgb2luv | Convert a rgb image into float luv color space image |
| biasscaleshiftimage | Scales and shifts image values in given range |
| biassetprojection | Load image and projection given by the command line, set projection in image and save image to disk |
| biassetrefuuid | Loads two images and sets UUID from second image to first image |
| biassetuid | Load image given by the command line, assign a uuid and write back to disk |
| biasshowepi | Show epipolar lines for image pair (GTK Version) |
| BiasShowEpiApp | |
| biasshowepiwx | Show epipolar lines for image pair (WX Version) |
| biasshowsm | Tool for showing binary written GensSynthMatches |
| biastrianglemesh | Generate triangle mesh from depth map |
| biasview | Tool for displaying images (GTK version) |
| BiasViewApp | |
| biasviewwx | Tool for displaying images (WX version) |
| BIAS::Binomial< InputStorageType, OutputStorageType > | |
| Binomial | Binomial low pass filter class |
| BIAS::BlobDetectorBase< StorageType > | Purly virtual interface defining class for blob detectors |
| BIAS::BlobDetectorBFS< StorageType > | Detects multiple blobs in an image, image has to be black except blocks to detect |
| BIAS::BlobDetectorCCA< StorageType > | Does a Connected Component Analyis and gives information about regions in an image, like centroid and bounding boxes |
| BIAS::BlobDetectorLevelSet< StorageType > | Evaluates a segementation into fore/back-ground |
| BIAS::Bresenham | Scans a line using Bresenhams integer arithmetic algorithm
|
| BIAS::BresenhamCircle | Scans a circle using Bresenhams integer arithmetic algorithm
|
| BIAS::BresenhamCircleEighth | Just like bresenham circle but only return 1/8th of the circle |
| BIAS::BresenhamCircleSlow | Makes 8 subsequent calls BresenhamCircleEighth slow does not work so far |
| BIAS::BSplineCurve | This class is intended for drawing of quadratic and cubic regular B-Splines from given control points |
| BWM_LUT_Entry | Base class for storing precomputed look-up information in BackwardMapping |
| BIAS::BWM_LUT_Entry_Anisotropic | Base class for storing precomputed lookup information for anisotropic interpolation in BackwardMapping |
| BIAS::BWM_LUT_Entry_Bicubic | Base class for storing precomputed lookup information for bicubic interpolation in BackwardMapping |
| BIAS::BWM_LUT_Entry_Bilinear | Base class for storing precomputed lookup information for bilinear interpolation in BackwardMapping |
| BIAS::BWM_LUT_Entry_Nearest | |
| BIAS::BWM_LUT_Entry_Trilinear | Base class for storing precomputed lookup information for trilinear interpolation in BackwardMapping |
| BIAS::CalibratedImage< StorageType > | Helper class holding image and associated calibration |
| BIAS::CalibratedPyramid< StorageType > | This class takes care of consisiten re-sampling of images and associated ProjectionParameters |
| BIAS::Camera< StorageType > | Extends the Image by MetaData support (e.g |
| BIAS::CameraData | |
| CameraInfo_s | |
| BIAS::CameraParam | |
| CameraParameter_s | |
| BIAS::CameraViewController | Base for (interactively) manipulating a (virtual) camera view |
| BIAS::CameraViewExternals | Describes external params of a camera view Used e.g |
| BIAS::CameraViewFrustum | Describes internal parameter Frustum of an (OpenGL) camera view |
| BIAS::CameraViewInternals | Describes internal params of an (OpenGL) camera view |
| BIAS::CameraViewport | Describes internal parameter viewport of an (OpenGL) camera view |
| BIAS::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 |
| BIAS::CanCompare< T1, T2 > | 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 |
| BIAS::CanCopy< T1, T2 > | 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 |
| BIAS::CanMultiply< T1, T2, T3 > | 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 |
| BIAS::CannyEdge< InputStorageType, OutputStorageType > | Canny edge detector |
| BIAS::CCAStruct | |
| BIAS::CensusTransform< InputStorageType, OutputStorageType > | 3x3 Census Transform of greyscale image |
| BIAS::CheckerboardDetector | Detect am asymmetric checkerboard pattern, typically 7x4 inner corners |
| BIAS::CheckerBoardExtractApp | |
| BIAS::CheckerBoardExtractFrame | |
| BIAS::CheckUtils | |
| child | |
| Child | |
| Child2 | |
| BIAS::Cholesky | |
| cilist | |
| cllist | |
| BIAS::ColorFilter< InputStorageType, OutputStorageType > | Extract single colour channels and their ratios |
| BIAS::ColorHarris | Detects Harris Features on color images |
| BIAS::ColorHistogram< StorageType > | This Class handels Histogram matters on Images |
| BIAS::ColorMultiHistogram< StorageType > | This Class handels MultiHistogram matters on Images |
| BIAS::ColorSegmentation | |
| BIAS::ColorSegmentationThreaded | |
| BIAS::ColourRGB< StorageType > | Interface class used to ease handover in function calls |
| Compare | |
| complex | |
| complex_comp | |
| BIAS::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 |
| BIAS::CondensHisto | Class for tracking an object in an image |
| BIAS::CondensImg | Example class for condensation with a 2-dim state vector |
| BIAS::Conic2D | A 3x3 matrix representing a conic (cone/plane intersection) |
| TNT::const_Region1D< Array1D > | |
| TNT::const_Region2D< Array2D > | |
| BIAS::ConstantRegionDetector< StorageType, CalculationType > | Detects regions with close to zero gradients in images |
| BIAS::ContourBSplineData | Data object which holds all infomations of a B-Spline curve (ContourBSpline); its shared by B-Spline curves with same basis |
| BIAS::ContourBSplineShapeMatrix | Data object which holds a shape matrix or regularisation matrix for a b-spline curve; could be shared by some ContourBSpline objects |
| BIAS::ContourBSplineType | |
| BIAS::ContourDetectorBase< StorageType > | Purly virtual interface defining class for contour detectors |
| BIAS::ContourDetectorBSpline< StorageType > | Special B-Spline and holds functions to handle fitting |
| BIAS::ContourDetectorSimple< StorageType > | Class for calculating the contour of a segmented region |
| BIAS::Control | |
| BIAS::ControlFactory | |
| convertRAW | Demonstrates reading of RAW4096 image format Reads a .raw RAW4096 image which contains a scorpion 1600x1200 Bayer raw pattern with 8 bpp and writes it as a jpeg |
| BIAS::Convolution< InputStorageType, OutputStorageType > | Generic convolution class |
| BIAS::CornerDetectorBase< StorageType > | Purly virtual interface defining class for corner detectors |
| BIAS::CornerDetectorFoerstner< StorageType, CalculationType > | Foerstner corner detector, detects grey value corners in images |
| BIAS::CornerDetectorGradient< StorageType, CalculationType > | Base class for all gradient based corner detectors |
| BIAS::CornerDetectorHarris< StorageType, CalculationType > | Harris corner detector, detects grey value corners in images |
| BIAS::CornerDetectorKLT< StorageType, CalculationType > | Computes the cornerness as the smaller eigenvalue of the structure tensor matrix |
| BIAS::CornerDetectorSusan< StorageType > | The Susan corner detector (oxford implementation, see license) |
| BIAS::CornerMatcher | Class with various functions to detect corresponding image points |
| BIAS::cornerstruct | Used only by Susan corner detector |
| BIAS::CorrespondenceMap< StorageType > | Holds dense 2d correspondences (flow field) for an image |
| BIAS::Cov3Dto2DPoseCertain | Project a 3D covariance matrix into the image plane using the unscented transform assuming that the pose is certain |
| BIAS::Covariance3Dto2D | Projection of 3D points with uncertainties covariances into the 2d image plane taking the camera pose uncertainty into account |
| BIAS::Covariance3Dto2DHomg | Projection of 3D points with uncertainties covariances into the 2d image plane taking the camera pose uncertainty into account |
| BIAS::CovEuler2Quaternion | Conversion of a rotation covariance in Euler-angles representation to a covariance in Quaternion representation using the unscented transform |
| BIAS::CovMatrix3x3 | Class for 3x3 covariance matrices |
| BIAS::CovQuaternion2AxisAngle | Conversion of a rotation covariance in quaternion representation to a covariance in axis-angle representation using the unscented transform |
| BIAS::CovTransformPose | Transformations between different representations of poses and their covariances (e.g |
| BIAS::CPDiscreteParam | |
| BIAS::CScommBase | This class CScomm (ClientServer communciation) handles data comunication via TCP/IP for one server and multiple clients |
| BIAS::CScommClient | Class for sending/receiving data between clients and servers |
| BIAS::CScommData | |
| BIAS::CScommMsg | Helper classes for CScommBase |
| BIAS::CScommServer | Class for sending/receiving data between clients and servers |
| BIAS::CSCommWithClientNr | Needed for the creation of receivethreads |
| CuEye | |
| CutoutFrame | |
| BIAS::CylinderMapping | Functions for spherical undistortion of given images, needs image dimensions, principal point and focal length as input additional to the image data |
| BIAS::CylindricalRectification< InputStorageType, OutputStorageType > | Class implements rectification by image projection onto a cylinder |
| BIAS::CylindricDepthPanorama | Create and represent cylindric depth panorama |
| BIAS::CylindricDepthTrackingPanorama | |
| BIAS::DC_GPS | |
| BIAS::DC_inertial | |
| BIAS::DC_ptu | |
| BIAS::Debug | |
| DebugMyMain | Example for usage of BIAS::Debug functionality |
| BIAS::DeInterlace< InputStorageType, OutputStorageType > | |
| DepthCalibrationFrame | Derived from wxFrame, ICECCallBackInterface |
| BIAS::DerivedFrom< T, B > | 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 |
| BIAS::Dilation< InputStorageType, OutputStorageType > | Dilation operator for binary images (black and white) |
| BIAS::DisplacementMapping< InputStorageType, OutputStorageType > | Maps image src to image sink with displacement mapl generated by backwardmapping method |
| BIAS::DistImgMatAcc< StorageType > | |
| BIAS::Distribution | Class for calculating mean, variance and possibly other parameters |
| BIAS::DistTransform< InputStorageType, OutputStorageType > | Class for calculating the distance transform |
| BIAS::dndFileTarget | Drag and drop files onto application |
| doublecomplex | |
| BIAS::doubleRANSAC | |
| BIAS::DPPanTiltControl | This class controls the Digital Perception Pan Tilt Unit |
| BIAS::DPPanTiltControlDialog | |
| DragAndDropTarget | Drag and drop files onto application |
| BIAS::DrawTextGL | Draw text to OpenGL as 2D bitmap font |
| BIAS::Edge_s | Struct for easier handling of edges |
| BIAS::EightWaySymmetry< T > | |
| BIAS::EightWaySymmetryHomg | Direction of line if start is in coordinate origin as given by compass |
| BIAS::Ellipsoid3DData | Stores important data for drawing an el4000lipsoid |
| BIAS::EMatrix | Class representing an Essential matrix |
| BIAS::EMatrixBase | Describes the epipolar relationship between two images whith known internal camera calibration |
| BIAS::EParametrization | Slim class bundeling essential matrix parametrization and associated covariance matrix |
| BIAS::EpipolarLine | |
| BIAS::Erosion< InputStorageType, OutputStorageType > | Erosion operator for binary images (black and white) |
| BIAS::EssentialPoint2Line | Computes line and associated covariance matrix given by a point and an essential matrix using unscented transform |
| BIAS::EuclideanTransf3D | Euclidean transformation for 3D points |
| ExampleArray2D | Example for usage of class Array2D |
| ExampleBresenham | Example for using bresenham drawing circle and line |
| ExampleCannyEdge | Example for using Canny Edge Detector |
| ExampleChessboard | Example for drawing a chessboard in an image |
| ExampleCompare | Example for comparing two floats |
| ExampleConstraints | Example for derivation of templates classes |
| ExampleConvert | Example for converting images (Clormodel) |
| ExampleCopy | Example for copying of BIAS::Debug object |
| ExampleDebug | Demonstrates the new usage of debuglevels the new concept avoids multiple definitions of debuglevels |
| BIAS::ExampleDebug | |
| ExampleDraw | Example for drawing in images |
| ExampleDraw2 | Simple example that draws
|
| ExampleEmpty | Example for generating an empty image |
| ExampleEParametrization | Example for the parameter of the EMatrix and usage |
| ExampleFileNames | Example for how to split a full path into its components directory, base of filename and extension of the filename |
| ExampleFMatrix | Example computing F matrix with 8-point, non-lin optimize, and gold standard |
| ExampleFMatrix2 | Example computing F matrix with 8-point, non-linear optimize, and gold standard |
| ExampleForeignData | Example for initialysing an image with the data of another image |
| ExampleGaussJordan | Example Gauss-Jordan on Matrix |
| ExampleGenerateGauss | Example for convolution of two matrices |
| ExampleGLSharedApp | |
| ExampleHSVConversion | Example converting an image to/from HSV colormodel |
| ExampleHSVConversion2 | Second example converting an image to/from HSV colormodel |
| ExampleImageAttributes | Access Image attrobute susing ImageMagick, e.g |
| ExampleImageCanvasGLBaseApp | |
| ExampleImageLoad | Load an arbitrary format from disk trying all availbale libraries |
| ExampleImageMagickIO::cpp | How to use the ImageMagick IO routines directly instead of all vailable routines from BIAS::ImageIO::Load |
| ExampleImageOperator | Example for operators on images |
| ExampleImageTypes | Check if all templates instances link correctly such that the bias_Config.h settings match those instances in BIASImageBase lib |
| ExampleImageWinApi | Demonstrates loading a .bmp file via MS Windows system calls without any third party library |
| ExampleInterpolation | Example for image interpolation with bicubic, bilinear |
| ExampleIpl | OpenCV/IPL image format acces |
| ExampleIplImageDisplay | OpenCV/IPL image format acces and display |
| ExampleIplImageDraw | OpenCV/IPL image draw |
| ExampleIplWrapOpenCV | Howto use the wrapper to use a BIAS imaeg with OpenCV image algorithms |
| ExampleJPEGCompress | Load an arbitrary format from disk and use libJpeg to convert it to JPEG-image with given (dflt 60) quality |
| ExampleJPEGDecompress | Reads a JPEG image from disk and prints image info |
| ExampleLoadBan | Load 3x4 matrix from Boujou .ban file |
| ExampleLoadBOG | Shows how to read the BOG format which is used by DaimlerChrysler |
| ExampleLogFacility | Example for using the logging facility |
| ExampleMatrix3x3 | Example for Matrix3x3 |
| ExampleMatrixConvolution | Example for convolution of two matrices |
| ExampleMetaData | Example for Image/Camera Meta Data usage |
| ExampleMEX | This is a small example of a library that can be called from MATLAB (C) to execute a simple matrix-multipl |
| ExampleMinMax | Example for determination if min and max pixel value in images |
| ExampleMixtureOfGaussiansApp | |
| BIAS::ExampleMixtureOfGaussiansFrame | Example for usage of MixtureOfGaussians scene change detection example for usage of MixtureOfGaussians scene change detection |
| ExampleOpenGLCanvasApp | |
| ExampleOperators | Example for Vector and Matrix operators |
| ExamplePMatrixBase | Example PMatrixBase usage |
| ExamplePolynom | Example Polynom usage |
| ExampleProgressSemaphore | Example for ProgressSemaphore registering in ProgressSemaphorePool |
| ExampleQuaternion | Example Quaternion usage |
| ExampleRandom | Example for random number generator |
| ExampleRandom2 | Example2 for random number generator |
| ExampleRandom2D | Example2D for random number generator |
| ExampleRectification | Example for image rectification |
| ExampleRMatrix | Example RMatrix usage |
| ExampleROI | Example for usage of Image ROI (Region Of Interest) |
| ExampleSharedPtr | Example for SharedPointer usage |
| ExampleSimpleGLApp | Examples for very simple GL application with a single scene |
| ExampleSingleton | Example for Singleton usage |
| ExampleSparseArray2D | Example for a sparse array 2D |
| ExampleSymmetricMatrix3x3 | Example for a symmetric matric |
| ExampleTile | Example for pasting an image to an Image ROI (Region Of Interest) |
| ExampleTimeMeasureCycle | Example time measurement |
| ExampleTypeSizes | Example sizes if types |
| ExampleUUID | Example for setting a UUID to an image |
| ExampleWin32Compat | Example for W32Compat usage ,e.g |
| ExampleXMLBase | Example XMLBase operations |
| ExampleXMLIO | Example XMLIO operations |
| BIAS::ExifTag | Helper class containing EXIF Tag info and its's value |
| BIAS::ExtendedKalman | Classical ExtendedKalman-filter (EKF) |
| Father | |
| BIAS::Feat | Internal class for feature passing only |
| BIAS::FFT | |
| BIAS::FFT2D< InputStorageType, OutputStorageType > | Wrapper to the fftw3 library use fast as follows: |
| BIAS::FFT2D_Tiles< InputStorageType, OutputStorageType > | |
| BIAS::FilterBase< InputStorageType, OutputStorageType > | Virtual parent class for API definition of all (future) filters |
| BIAS::FilterMask | A filter mask (or a kernel) used for convolution |
| BIAS::FilterNTo2N< InputStorageType, OutputStorageType > | Base class for simple n->2n filter implementations |
| BIAS::FilterNTo2NFactory< InputStorageType, OutputStorageType > | Creates N-to-2N filters by class name |
| BIAS::FilterNTo3N< InputStorageType, OutputStorageType > | Base class for simple n->3n filter implementations |
| BIAS::FilterNTo3NFactory< InputStorageType, OutputStorageType > | Creates N-to-3N filters by class name |
| BIAS::FilterNToN< InputStorageType, OutputStorageType > | Base class for simple n->n filter implementations |
| BIAS::FilterNToNFactory< InputStorageType, OutputStorageType > | Creates N-to-N filters by class name |
| BIAS::FilterTestPair< InputStorageType, OutputStorageType > | Struct holding ground truth data for filter testing\ |
| FindFilesInPath | |
| BIAS::FitCircleFrame | |
| BIAS::FMatrix | Class representing a Fundamental matrix |
| BIAS::FMatrixBase | Describes the epipolar relationship between a point and his mapping on a corresponding epipolar line |
| BIAS::FMatrixEstimation | Functions for estimating a fundamental matrix (FMatrix) given a set of 2d-2d correspondences (no outlier checks, not robust !) in two views |
| foo | Some base class |
| TNT::Fortran_Matrix< T > | |
| TNT::Fortran_Sparse_Col_Matrix< T > | |
| TNT::Fortran_Sparse_Vector< T > | |
| BIAS::ForwardMappingNearestNeighbour< InputStorageType, OutputStorageType > | |
| FromBase | |
| BIAS::Gauss< InputStorageType, OutputStorageType > | Smoothing with gaussian kernel |
| BIAS::GaussHelmert | See Foerstner, 2004, "Uncertainty And Projective Geometry" ! untested ! |
| BIAS::GaussThreshold< InputStorageType, OutputStorageType > | Smoothing with gaussian kernel using a threshold |
| BIAS::GenerateGauss | Compute one and two dimensional gauss normal distribution |
| BIAS::GenGroundTruth | |
| BIAS::GenSynthMatches | Class for generating synthetic matches |
| BIAS::GenSynthMatchesRig | Generates synthetic matches for cameras in a rig |
| BIAS::GenVisiblePoints | Class for generating 3D points visible by a set of cameras |
| BIAS::GeometryGL | Reusable Geometry an drawing functions for OpenGL |
| BIAS::glfBatch | A batch represents a single Draw call including all parameters (render states) |
| BIAS::glfBlendMode | Defines the function that blends rendered geometry with its background |
| BIAS::glfCubeMap | A cube map texture |
| BIAS::glfDepthBufferMode | Defines the usage of the depth buffer |
| BIAS::glfElementBuffer | An element buffer contains vertex indices that form primitives |
| BIAS::glfException | Exception class used for run-time errors in the OpenGLFramework |
| BIAS::glfFBOAttachmentReleaseException | Class is thrown when an release of some FBO attachment point is not possible |
| BIAS::glfFramebufferObject | Framebuffer object |
| BIAS::glfMatrix | A 4x4 matrix in native OpenGL format |
| BIAS::glfPassiveDepthBufferMode | This class allows to use the currently set viewport in the global opengl state! |
| BIAS::glfPassiveRenderMatrix | This class allows to use the currently set RenderMatrix in the global opengl state! |
| BIAS::glfPassiveRenderTarget | This class allows to use the currently set RenderTarget in the global opengl state! |
| BIAS::glfPassiveViewport | This class allows to use the currently set viewport in the global opengl state! |
| BIAS::glfPBuffer_GLX | GLX pbuffer rendering context |
| BIAS::glfPBuffer_WGL | WGL pbuffer rendering context |
| BIAS::glfRenderbuffer | |
| BIAS::glfRenderingContext | Interface for OpenGL rendering contexts |
| BIAS::glfRenderingContext_GLX | Base class for GLX rendering contexts |
| BIAS::glfRenderingContext_WGL | Base class for WGL rendering contexts |
| BIAS::glfRenderingContextConfig | Configuration for a rendering context |
| BIAS::glfRenderTarget | Interface for render targets |
| BIAS::glfScreen | Represents the default render target of the current OpenGL context, i.e |
| BIAS::glfShader | A GLSL vertex shader or fragment shader, which must be linked in a shader program |
| BIAS::glfShaderProgram | A shader program composed of several shaders |
| BIAS::glfTexture | Base class for textures |
| BIAS::glfTexture2D | A 2D texture |
| BIAS::glfVertexBuffer | A vertex buffer contains an array of vertices that can be used for rendering |
| BIAS::glfVertexFormat | A vertex format describes the attributes of a vertex |
| BIAS::glfVertexFormat::AttributeDesc | |
| BIAS::glfViewport | |
| BIAS::GrabMasterThread | *************************************************************** |
| BIAS::GrabSingleThread | *************************************************************** |
| BIAS::GradientGauss< InputStorageType, OutputStorageType > | Gradient calculation with separated gauss masks |
| BIAS::GradientGaussAsymmetric< InputStorageType, OutputStorageType > | Gradient calculation with separated gauss masks |
| BIAS::GradientSimple< InputStorageType, OutputStorageType > | 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) |
| BIAS::GradientSobel3x3< InputStorageType, OutputStorageType > | Gradient calculation with sobel 3 by 3 masks |
| BIAS::GraphPlotter | Use this class to plot data as gnuplot does |
| GuessCoo2WoorlCoo | |
| BIAS::GuiBase | Gui is a simple windowing environment |
| BIAS::GuiCV | Gui based on OpenCV is a simple windowing environment |
| BIAS::GuiEnhanced | Extended GuiGTK with zoom and marking options |
| BIAS::GuiGTK | Gui based on gtk is a simple windowing environment |
| helloconfig | Test makefile generation and linking against BIAS lib |
| BIAS::HessianGauss< InputStorageType, OutputStorageType > | Gradient calculation with separated gauss masks |
| BIAS::HessianSimple< InputStorageType, OutputStorageType > | Simple hessian calculation hxx(x,y) = Hessian in x direction hyy(x,y) = Hessian in y direction |
| BIAS::Histo_Entry_Float | |
| BIAS::HistoFrame | |
| BIAS::Histogram | Class for easy histogram generation |
| BIAS::Histogram1D< T > | Simple one dimensional histogram computation |
| BIAS::Histogram2D | |
| Histogramm_float_Entry | Used by ImageCanvas and ScaledImageCanvas, should not be used directly |
| BIAS::HistoImageCanvas | |
| BIAS::HMatrix | 3x3 Matrix describing projective transformations between planes |
| BIAS::HMatrixBase | Describes a homography |
| BIAS::HMatrixEstimation | Estimate 3x3 Matrix (homography, affine transformation, |
| BIAS::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 |
| BIAS::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 |
| BIAS::HomgPlane3D | A homogeneous plane (in P^3) All points X on the plane p fulfill p ' * X = 0 |
| BIAS::HomgPoint1D | Class HomgPoint1D describes a point with 2 degrees of freedom in projective coordinates |
| BIAS::HomgPoint2D | Class HomgPoint2D describes a point with 2 degrees of freedom in projective coordinates |
| BIAS::HomgPoint2DCov | Class representing the covariance matrix of a homogenous point 2D |
| BIAS::HomgPoint3D | Class HomgPoint3D describes a point with 3 degrees of freedom in projective coordinates |
| BIAS::HomgPoint3DCov | Class representing the covariance matrix of a homogenous point 3D |
| BIAS::HomographyMapping< InputStorageType, OutputStorageType > | Maps image src to image sink with homography H (software implementation) |
| BIAS::HomographyRectification< InputStorageType, OutputStorageType > | |
| BIAS::ICECallbackInterface | |
| ICECallBackInterface | Callback interface for ImageCanvasExtended |
| BIAS::ICECCallbackInterface | |
| ICECCallBackInterface | Callback interface for ImageCanvasCheckerBoardExtract |
| icilist | |
| BIAS::Image< StorageType > | The image template class for specific storage types |
| BIAS::Image3DData | Stores datas for a textured plane |
| BIAS::ImageAlignment | Inverse Compositional Image Alignment ("Registration") |
| BIAS::ImageAttributes | All atribute info and values of e.g. a file |
| BIAS::ImageBase | This is the base class for images in BIAS |
| BIAS::ImageBlender | Maps images into a common camera and blends them seamlessly |
| BIAS::ImageCanvas | Display image in wx application, provides zoom and investigation functionality |
| BIAS::ImageCanvasCheckerboardExtract | Functionality for selection of checkerboard patterns |
| BIAS::ImageCanvasEnhanced | Functionality for selection of rectangle, point, |
| BIAS::ImageCanvasGLBase | |
| ImageCanvasGLBase | 2D image display canvas using OpenGL rendering internally |
| BIAS::ImageConvert | Class with static functions for converting all kinds of color formats and storage types |
| BIAS::ImageConvertThreaded | |
| BIAS::ImageDraw< StorageType > | Drawing simple entities into the image like rectangles or lines |
| ImageHeader | |
| BIAS::ImageIO | Routines for loading and writing all kinds of image formats
|
| BIAS::ImagePackage | |
| BIAS::ImagePackage::IPFileInfo | |
| BIAS::ImagePackage::IPImageHeader | |
| BIAS::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 |
| BIAS::ImgObjGL | Data holder describing OpenGL texture objects in addition to its unique texID |
| BIAS::ImgPosition | Interface class used to ease handover in function calls |
| TNT::Index1D | |
| BIAS::IndexedFaceSet | Stores data for drawing a indexed face set |
| inlist | |
| BIAS::IntegralHistogram | This Class handels Integral Histograms on HSL Images It represents an integral image histogram and offers basic methods on histograms |
| BIAS::Interpolator | This class interpolates a function y=f(t) between given control points (the y-values) |
| IntroductionFrame | |
| BIAS::IOUtils | Class grouping together some IO code often used in (small) application, like loading images, parsing their meta data etc |
| BIAS::IOUtils::ProgressBar | |
| BIAS::IOUtils::ProgressIndicator | |
| BIAS::ItemAndWidget | |
| BIAS::JointHistogram< StorageType > | |
| BIAS::JpegHandler | Wrapper for fast libjpeg methods Class for mem-to-mem JPEG-compression. Compress a given BIAS::Image (unsigned char) to data-array in shared memory file or decompress a given JPEG-file located in user memory into a BIAS::Image (u. char) |
| BIAS::Kalman | Classical Kalman filter |
| BIAS::KMatrix | K describes the mapping from world coordinates (wcs) to pixel coordinates (pcs) |
| BIAS::Label | Does a connected component analysis and labels all connected regions |
| BIAS::LaguerreSolver | Class encapsulating a laguerre solver for polynomials |
| BIAS::LeastSquaresBase | |
| BIAS::LeastSquaresLapack | |
| BIAS::LeastSquaresSVD | |
| BIAS::Line3DData | Stores data for drawing a line |
| BIAS::LinearRegionDetector< StorageType, CalculationType > | Try to detect linear regions (const gradient) in images, experimental code for testing |
| BIAS::LocalAffineFrame | Affine transformation of 2D image plane which relates image coordinate system and local affine feature coordinate system |
| BIAS::LogFacility | |
| BIAS::LogPolarMapping< InputStorageType, OutputStorageType > | Maps cartesian source coordinates to log-polar sink coordinates |
| TNT::LowerTriangularView< MaTRiX > | |
| MainFrame | |
| BIAS::ManualControl | |
| BIAS::ManualControlFactory | |
| BIAS::MatchDataBase | Class for representing matches, used in GenSynthMatches and biasshowsm |
| MathBaseOperators | Test basic math operators |
| BIAS::MatlabTBUndistortion | |
| BIAS::MatlabTBUndistortion::LuTEntry | |
| BIAS::Matrix< T > | Matrix class with arbitrary size, indexing is row major |
| TNT::Matrix< T > | |
| BIAS::Matrix2x2< T > | 'fixed size' quadratic matrix of dim |
| BIAS::Matrix3x3< T > | 'fixed size' quadratic matrix of dim |
| BIAS::Matrix3x4< T > | 'fixed size' rectangular matrix of dim |
| BIAS::Matrix4x4< T > | 'fixed size' quadratic matrix of dim |
| MatrixInterfaceCheck< MATRIX_CLASS, VECTOR_CLASS, T > | Class capsulating the checks for interfaces of Matrix* classes without using inheritance and thus avoiding the overhead induced by the vtable |
| BIAS::MatrixPanel | Panel for displaying and editing matrices |
| BIAS::MDcam | VideoG |
| BIAS::Mean< InputStorageType, OutputStorageType > | Deinterlacer filter |
| BIAS::Median< InputStorageType, OutputStorageType > | 2D median filter |
| BIAS::Median1D< DataType > | Computes the median of a vector |
| BIAS::Median< InputStorageType, OutputStorageType >::FloatPair | |
| BIAS::message_frame_buffer | |
| message_frame_header | |
| BIAS::MetaData | This class collects all additional data chunks of type AppData to be written into/read from an image file |
| BIAS::MixtureOfGaussians< StorageType > | Class for detecting changes in image sequences |
| BIAS::MonteCarloTransform | Monte carlo propagation of uncertainty |
| BIAS::Morphology< InputStorageType, OutputStorageType > | Base class for Erosion, Dilation, and single Deletion |
| BIAS::MSAC< SolutionType > | |
| Multitype | |
| BIAS::MutexSingleton | Wrapper for pthread mutex for use with 'automatic' initialization |
| my_error_mgr | |
| MyAlgorithm | |
| MyApp | |
| myclass | |
| MyClass | |
| MyFrame | |
| MyGLCanvas | Implement your own OopenGLCanvas derived class and override one of the Display functions to plug in your own GL calls / GL scene |
| MyGLCanvas2 | |
| BIAS::MyKalman | Very simple filter for estimating a constant value |
| MyMonteCarloTransform | |
| BIAS::MySampleGrabberCB | |
| MyScene | |
| MyTemplate< T > | |
| myTestClass | |
| MyTestClass | |
| MyUnscentedTransform | |
| Namelist | |
| NonBase | |
| BIAS::Normalization | Class Normalization Functions, e.g |
| olist | |
| BIAS::OpenGLCanvas | OpenGL canvases with additinal event handling (JW) |
| BIAS::OpenGLCanvasBase | Base class for OpenGL canvases you could derive from to get base functionality (JW) |
| option | |
| BIAS::Param | This class Param provides generic support for parameters |
| BIAS::ParamCallbackInterface | This class provides an interface to be called if parameter changes occured |
| BIAS::Parametrization | This class is used for parametrizing F- and H-matrices, generally for optimization purposes |
| BIAS::ParamGUI | ?? |
| BIAS::ParamGUIDialog | |
| BIAS::ParamGUIPanel | ?? |
| BIAS::ParamTypeBase | This file holds the definitions of the parameter types used by BIAS::Param |
| BIAS::ParamTypeBool | |
| BIAS::ParamTypeDouble | |
| BIAS::ParamTypeEnum | |
| BIAS::ParamTypeInt | |
| BIAS::ParamTypeString | |
| BIAS::ParamTypeVecDbl | |
| BIAS::ParamTypeVecInt | |
| parent | |
| BIAS::PixelIterator | Can be used to run along the image border |
| PlainImageCanvas | |
| BIAS::PlanarRectification< InputStorageType, OutputStorageType > | Rectification via perspective cameras, removes distortions |
| BIAS::PlaneRANSAC | |
| BIAS::PlueckerMatrix | Represente a 3d line using a 4x4 Pluecker matrix |
| BIAS::PMatrix | Describes a projective 3D -> 2D mapping in homogenous coordinates |
| pmatrix2projection | Convert PMatrix to BIAS::Projection |
| BIAS::PMatrix3DData | Stores important data for drawing a camera |
| BIAS::PMatrixBase | Describes a projective 3D -> 2D mapping in homogenous coordinates |
| BIAS::PMatrixEstimation | Compute standard P1/P2 from F |
| BIAS::PMatrixLinear | This class computes a PMatrix from 2D/3D correspondences with linear methods |
| PMDCamToShm | Opens a PMD camera and writes images to a shared memory object |
| BIAS::PMDImageIO | Save 2D/3D-image-data together with some metadata in a single tiff-datafile |
| BIAS::PMDImageMetaData | Store extrinsic and intrinsic camera parameters for Rotation is in axis * angle representation image padding and Metadata |
| BIAS::PMDImageProc | |
| BIAS::Point3DData | Stores data for drawing a point |
| BIAS::Polynom | Class for Polynoms of arbitary order |
| BIAS::PolynomialSolve | Base class for solving polynomial equations |
| BIAS::Pose | Container for 3D pose, parametrized as euclidean center and quaternion orientation |
| BIAS::PoseParametrization | Slim class bundeling pose parametrization and associated covariance matrix |
| BIAS::PoseParametrizationCovariance | Class encapsulating the transfromations between different pose parametrizations |
| BIAS::Position | Stores valid/nvalid positions in image |
| BIAS::PreemptiveRANSAC< SolutionType > | |
| BIAS::PreemptiveRANSAC< SolutionType >::SolStruct | |
| BIAS::ProgressSemaphore | |
| BIAS::ProgressSemaphorePool | |
| Projection | This class hides the underlying projection model, like projection matrix, spherical camera, lens distortion, |
| BIAS::Projection3DData | Class Projection3DData stores data for drawing a the extrinisc paramters of a projection |
| BIAS::ProjectionDialog | Dialog containing a ProjectionGUI |
| BIAS::ProjectionGUI | Panel for displaying and editing projections |
| BIAS::ProjectionMapping< InputStorageType, OutputStorageType > | Maps source pixel to sink pixel of given projections |
| BIAS::ProjectionParametersBase | Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as camera pose |
| BIAS::ProjectionParametersCylindric | Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose |
| BIAS::ProjectionParametersFactory | |
| BIAS::ProjectionParametersGreatCircles | Spherical camera that samples along big circles containig the H vector |
| BIAS::ProjectionParametersIO | |
| BIAS::ProjectionParametersPerspective | Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose |
| BIAS::ProjectionParametersPerspectiveDepth | Additional depth calibration parameters for a perspective depth camera |
| BIAS::ProjectionParametersProjective | 12 parametric p for completely projective reconstruction scenarios, unknown focal lengths, self calibration, |
| BIAS::ProjectionParametersSpherical | Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose |
| BIAS::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 |
| BIAS::ProjectionParametersZoom | Camera parameters which define the mapping between rays in the camera coordinate system and pixels in the image as well as external pose |
| BIAS::PyramidImage< StorageType > | Class for holding downsampled images |
| BIAS::PyramidImageInterface< StorageType > | Interface definition of all pyramid images |
| BIAS::Quadric3 | |
| BIAS::Quadric3D | A Quadric as a 4x4 matrix (surface in P3 defined by a quadratic equation, e.g |
| BIAS::Quaternion< QUAT_TYPE > | Class for rotation with axis and angle |
| BIAS::Random | Class for producing random numbers from different distributions |
| BIAS::RANSAC< SolutionType > | Do not DLL export this class because it is headeer only |
| BIAS::RANSACPreKnowledge< SolutionType > | Extension of RANSAC algorithm: user-supplied guesses are evaluated and refined using RANSAC criterions before actually starting the RANSAC algorithm |
| BIAS::RectificationBase< InputStorageType, OutputStorageType > | Base class for rectification implementations and wrappers |
| BIAS::RectificationViaProjectionMappingBase< InputStorageType, OutputStorageType > | 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 |
| BIAS::RedirectStreams | Used to redirect stdout and stderr into files or to silence them |
| TNT::Region1D< Array1D > | |
| TNT::Region2D< Array2D > | |
| BIAS::RegionMatcher | Basic functions for CornerMatcher |
| BIAS::RenderModeGL | GLRenderMode describes mode for rendering |
| BIAS::Rescale< InputStorageType, OutputStorageType > | Down-, Upsampling routines and Resize |
| BIAS::RescaleTransfer | Transfer of pixel coordinates for pixel centric reference systems |
| 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 |
| BIAS::RMatrix | 3D rotation matrix |
| BIAS::RMatrixBase | 3D rotation matrix |
| BIAS::ROI | Class for handling different region of interest (ROI) representations |
| BIAS::RParametrization | Slim class bundeling rotation matrix parametrization and associated covariance matrix |
| BIAS::SameButConst< EditableType, ConstType > | Compile time check if the ConstType differs from EditableType merely by a const qualifier, i.e |
| BIAS::ScaledImageCanvas | Display float images in wx application, provides zoom, scale, shift and investigation functionality |
| BIAS::ScanLine | Class for scanning a image region given by a line and a distance from the line |
| BIAS::ScanLine2 | |
| BIAS::SceneGL | Simple interface for GL calls |
| SegmentationData | |
| BIAS::SensorData | |
| BIAS::SettingsGL | Application controlled OpenGl renderingsettings |
| BIAS::SharedPtr< T > | Pointer with reference count and automatic deletion |
| BIAS::SharedPtr< T >::Tester | |
| BIAS::SharedPtrBase< T > | Pool ptr to the data and the reference count |
| BIAS::Shift< InputStorageType, OutputStorageType > | Pixels |
| ShowCamWx | Gui application for image grabbing and from various cameras |
| ShowCamWxApp | |
| BIAS::ShowCamWxFormat7Frame | |
| BIAS::ShowCamWxFrame | |
| ShowCamWxFrame | This class is the main frame of the ShowCamWx Application |
| BIAS::SimilarityTransform | |
| SimilarityTransformation3D | Calss rpresenting a similiraty transform, that can either be a coordinate transform or a movement of points |
| BIAS::SimpleGLApp | Simple GL application |
| BIAS::SimpleGLCanvas | Helper canvas for SimpleGLApp |
| BIAS::SimpleGLFrame | Helper frame for SimplaGLApp |
| SimpleSceneGL | JW |
| SimpleSceneGLData | JW |
| BIAS::Singleton< T > | Simple singleton implementation for multithreaded applications |
| BIAS::SoftMotion | |
| BIAS::SparseArray2D< T > | Generic two dimensional psarsly populated rectangular array holding arbitrary data types |
| BIAS::SparseArray2D< T >::const_iterator | For const_iterator access todo: derive from std::iterator class(es) |
| BIAS::SparseArray2D< T >::iterator | For iterator access todo: derive from std::iterator class(es) |
| BIAS::SparseMatrix | Implementation of sparse matrix operations |
| BIAS::SphericalCoordinates | Transformation between affine and spherical coordinates |
| BIAS::SphericalDepthPanorama | Create and represent spherical depth panorama |
| BIAS::SphericalRectification< InputStorageType, OutputStorageType > | Class implements rectification by image projection onto a sphere |
| BIAS::SphericalUndistortion | Transforms sphere images coming from a fisheye-lens according to different projection models |
| BIAS::SphericalUndistortion::LuTEntry | |
| BIAS::SphericalUndistortion::LuTpxpyEntry | |
| BIAS::StatekeeperGL | Push and pop GL states on constructor/destructor Helper class pop(save) OpenGL states on construction and push them on destruction automatically |
| BIAS::StereoRedGreen | Combine two separate images into one stereo image for red-green glasses |
| STestData | |
| TNT::stopwatch | |
| BIAS::StructureTensor< InputStorageType, OutputStorageType > | Basic class for structure tensor calculation |
| BIAS::SVD | Computes and holds the singular value decomposition of a rectangular (not necessarily quadratic) Matrix A |
| BIAS::SVD3x3 | Singular value decomposition for 3x3 matrices |
| BIAS::SymmetricMatrix3x3< T > | 'fixed size' symmetric quadratic matrix of dim |
| TagInfo | ----------------------------- |
| tagTHREADNAME_INFO | |
| BIAS::Tensor3D< T > | |
| BIAS::Tensor3D3x3x3< T > | |
| TestArray2D | Test Array 2D MIP |
| TestCompareFloatingPoint | Test comparison of floating point numbers MIP |
| testDefines | Test the defines used in BIAS |
| testEnv | Test environment for building BIAS |
| testError | Compiling this source code should intentionally produce a compilation error |
| BIAS::TestFilterBase< FILTER, InputStorageType, OutputStorageType > | Helper class for testing individual filters |
| TestFilterBinomial | Test the binomial filter |
| testFooLib | Simple test for linking against BIAS |
| testFooLibEXE | Test compiling, linking and runtime usage of a simple lib |
| TestLaguerre | Test Laguerre |
| TestMatrixIO | Test Matrix I/O precision issues |
| TestMatrixVectorIO::cpp | Test Matrix I/O precision issues |
| TestProjectionParametersSphericalSimple | Test the spherical projection parameters |
| TestRMatrix | Stupid test of RMatrix contruct |
| TestROI | Roi testing |
| TestRotationConversion | Test the conversion between rotation represenations MIP |