| _FilterBorders | |
| A | |
| BIAS::AbsoluteOrientation | Computes similarity transformation between 3D point sets |
| BIAS::AbsoluteOrientationRANSAC | Robust computation of similarity transformation between two 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 | |
| AutoControl | Class for camera movement in autopilot mode |
| BIAS::AutoControl::CameraPose | |
| BIAS::AutoControlFactory | |
| B | |
| 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::BaseFactory< BaseClassType, TagType > | Simple factory class designed for usage as a singleton |
| BIAS::BaseFactory< BaseClassType, TagType >::MapEntry | Struct for storing class details in member map Map_ |
| 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 images given by the command line and compute mean value for each pixel |
| 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) |
| BiasViewWXApp | Tool for displaying images (WX version) |
| BIAS::Bilateral< InputStorageType, OutputStorageType > | 2D bilateral filter |
| 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 |
| BIAS::BVWXApp | |
| BIAS::BVWXDnDTarget | Drag and drop files onto application |
| BIAS::BVWXMainFrame | The main frame of the BiasViewWX application |
| 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 |
| C | |
| 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 | Detects a checkerboard pattern in an image (typically 7x4 inner corners, asymmetric layout recommended) |
| BIAS::CheckerBoardExtractApp | |
| BIAS::CheckerBoardExtractFrame | |
| BIAS::CheckUtils | |
| child | |
| Child | |
| Child2 | |
| BIAS::Cholesky | |
| cilist | |
| cllist | |
| BIAS::ColFeat< StorageType > | Internal class for feature (with color) passing only |
| 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::ContextGLUT | Wrapper to glut-library |
| BIAS::ContextPBuffer | Wrapping class implementation for PBuffer class |
| BIAS::ContextWX | |
| ContextWx | Context implementation for wx |
| 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 | |
| BIAS::ControlInterface | Defines the common interface used for communication between rendering components |
| BIAS::ConvertHDR< StorageType > | This class handles conversions of HDR images to for example unsigned char |
| 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::DataPlot | |
| BIAS::DC_GPS | |
| BIAS::DC_inertial | |
| BIAS::DC_ptu | |
| BIAS::Debug | |
| DebugMyMain | Example for usage of BIAS::Debug functionality |
| BIAS::DeInterlace< InputStorageType, OutputStorageType > | |
| BIAS::DeMosaicing< StorageType > | Wrapper class to dc1394 bayer conversion class |
| 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) |
| disableZwriteNodeVisitor | |
| BIAS::DisplacementMapping< InputStorageType, OutputStorageType > | Maps image src to image sink with displacement mapl generated by backwardmapping method |
| BIAS::DistImgMatAcc< StorageType > | |
| BIAS::DistortionRendering | Utility class for distortion rendering used by GLProjection |
| 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::DragAndDropTarget | Drag and drop files onto application |
| BIAS::DrawTextGL | Draw text to OpenGL as 2D bitmap font |
| BIAS::DrawTextWx< StorageType > | 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 |
| 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 bundling essential matrix parameterization 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 |
| EvaluateAlignment | Alignment evaluation |
| ExampleAlignment | Alignment example |
| ExampleArray2D | Example for usage of class Array2D |
| ExampleBlobDetectorBFS | Example for usage of class BlobDetectorBFS |
| ExampleBlobDetectorCCA | Example for usage of class BlobDetectorCCA |
| ExampleBlobDetectorLevelSet | Example for usage of class BlobDetectorLevelSet Usage: Simple start this program |
| ExampleBresenham | Example for using bresenham drawing circle and line |
| ExampleCannyEdge | Example for using Canny Edge Detector |
| ExampleCheckerboard | Example for usage of Checkerboard Detector Usage: ExampleCheckerboard <filename> <inner_xCorners> <inner_yCorners> |
| ExampleChessboard | Example for drawing a chessboard in an image |
| ExampleColorNCC | This little example demonstrates the usage of color normalised cross correlation |
| ExampleCompare | Example for comparing two floats |
| ExampleConstantRegion | Example for usage of ConstantRegionDetector Usage: ExampleConstantRegion <im1> [ <im2> <im3> |
| ExampleConstraints | Example for derivation of templates classes |
| ExampleContourDetectorBSpline | Example for usage of ContourDetectorBSpline Usage: ContourDetectorBSpline example.ppm press f for fitting" <im1> [ <im2> <im3> |
| ExampleContourDetectorSimple | Example for usage of ContourDetectorSimple Usage: ContourDetectorSimple segmentedImage distanceImage contourImage |
| ExampleConvert | Example for converting images (Clormodel) |
| ExampleCopy | Example for copying of BIAS::Debug object |
| ExampleCornerDetector | Example for usage of CornerDetector Usage: ExampleCornerDetector [parameter] <im1> <im2> [ <im3> |
| ExampleDebug | Demonstrates the new usage of debuglevels the new concept avoids multiple definitions of debuglevels |
| BIAS::ExampleDebug | |
| ExampleDeMosaic | Example for demosaicing images using unsigned char image |
| 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 |
| ExampleFactory | Example for class factory |
| 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 | 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 |
| ExampleKLTEdge | This little example demonstrates the usage of the KLT edge detector |
| ExampleLineMatcher | This little example demonstrates the usage of line matching |
| 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 |
| BIAS::ExampleMixtureOfGaussians | |
| 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 |
| ExampleParabola | This little example demonstrates the usage of parabola |
| 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 |
| ExampleRefineContour | Example Contour Refinement Usage: ExampleRefineContour SegmentedImage ColorImage ContourImage |
| 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 |
| ExampleTracker | This little example demonstrates the most simple case of usage of the Tracker class |
| ExampleTrackerBase | This little example evaluates a TrackerBase class against synthetically generated ground truth data |
| ExampleTrackerBaseInterface | See TestData/affine in cvs for generating test images |
| 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::FFMPEGVideo | Class for extracting frames from video files |
| BIAS::FFT | |
| BIAS::FFT2D< InputStorageType, OutputStorageType > | Wrapper to the fftw3 library use fast as follows: |
| BIAS::FFT2D_free< StorageType > | |
| BIAS::FFT2D_Tiles< InputStorageType, OutputStorageType > | |
| BIAS::FileHandling | |
| BIAS::FilterBase< InputStorageType, OutputStorageType > | Virtual parent class for API definition of all (future) filters |
| BIAS::FilterDialogBase< InputST, OutputST > | Base class for all filter dialogs |
| BIAS::FilterDialogCannyEdge< InputST, OutputST > | Implementation of a CannyEdge filter dialog |
| BIAS::FilterDialogGauss< InputST, OutputST > | Implementation of a Gauss filter dialog |
| BIAS::FilterDialogGradientSobel3x3< InputST, OutputST > | Implementation of a GradientSobel3x3 filter dialog |
| BIAS::FilterDialogMean< InputST, OutputST > | Implementation of a Mean filter dialog |
| BIAS::FilterDialogMedian< InputST, OutputST > | Implementation of a Median filter dialog |
| BIAS::FilterDialogPreviewWindow< StorageType > | A preview window |
| BIAS::FilterDialogRescale< InputST, OutputST > | Implementation of a Rescale filter dialog |
| 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::FlyControl | Class for camera movement in fly mode |
| 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 > | |
| BIAS::FramebufferSetup | |
| BIAS::FramebufferSetupPool | Class containing a framebuffer and a map of setups |
| 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::glfArrayBufferObject | Wrapper for OpenGL array buffer objects |
| 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::glfBufferObject | Base class of wrapper for OpenGL 3.x buffer objects |
| 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::glfStencilBufferMode | Defines the usage of the stencil buffer |
| BIAS::glfTexture | Base class for textures |
| BIAS::glfTexture2D | A 2D texture |
| BIAS::glfUniformNotFoundException | Class is thrown when a uniform is set but was not set active by the gl compiler |
| 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::GLProjectionOutputAttachment | Class for extra rendering pass in GLProjection (for now only used in glutGLviewer) |
| BIAS::GLProjectionParametersBase | GLPPB encapsulates the opengl rendering interface for the projectionparameter classes |
| BIAS::GLProjectionParametersInterface | Abstract interface class to handle changes in rendering parameters by controllers and in rendering contextes |
| BIAS::GLProjectionParametersPerspective | |
| 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 |
| 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 | It's a Frame used to have a Histogramm Canvas, which describes a histogramm of current image |
| BIAS::Histogram | Class for easy histogram generation |
| BIAS::Histogram1D< T > | Simple one dimensional histogram computation |
| BIAS::Histogram2D | |
| Histogramm_float_Entry | Base class for storing computed histogramm information in HistoCanvas |
| BIAS::HistoImageCanvas | It's a Canvas used to compute Histogrammfor current image working |
| 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 | An Image Package is multiple .mip images in one file |
| 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::IselLinearControl | This class controls the Isel Linear Unit |
| 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::MainFrame | |
| makeTransparentNodeVisitor | |
| BIAS::ManualControl | |
| BIAS::ManualControlFactory | |
| BIAS::MatchDataBase | Class for representing matches, used in GenSynthMatches and biasshowsm |
| MathBaseOperators | Test basic math operators |
| TNT::Matrix< T > | |
| BIAS::Matrix< T > | Matrix class with arbitrary size, indexing is row major |
| 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 |
| MouseActionStruct | Grouping the mouseactions reported by GLUT |
| 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 | |
| BIAS::NodeInfo | Struct containing details of a OSG::Node when used in a wxTreeCtrlOpenSGWx |
| BIAS::NodeInfoEraseOp | |
| BIAS::NodeInfoMap | |
| BIAS::NodeInfoOpBase | |
| BIAS::NodeInfoOpenSGVisitor | Visitor for traversing the scene graph and applying some operation to the related nodeinfomap |
| BIAS::NodeInfoRestoreNameOp | |
| NonBase | |
| BIAS::Normalization | Class Normalization Functions, e.g |
| BIAS::OffscreenRendering | Utility class for offscreen rendering used by GLProjection |
| olist | |
| BIAS::OnlyRotationControl | Class for camera movement in fixed position, only rotation mode |
| BIAS::OpenEXRInterface | Methods for reading and writing OpenEXR files into and from BIAS ImageBase |
| BIAS::OpenEXRInterface::ChannelData | Used to maintain control of the heap when generating slices |
| 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) |
| BIAS::OpenSceneGraphHelper | |
| option | |
| BIAS::OutputHaze | Exemplary output attachment, creating a bluish haze effect on the rendered output |
| BIAS::OutputUnderwater | Exemplary output attachment, creating a bluish haze effect on the rendered output |
| BIAS::OutputWowDisplay | Exemplary output attachment to create 2D+Depth output for Wow Displays |
| BIAS::OutputWowDisplay2 | |
| BIAS::PanelForDoubleValueWx | Helper Class For Parameter Input To Take Floating Point Numbers |
| 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::PlainPerPixelProcessing | Class rendering quad and executing a fragment shader |
| 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::PMDWarp | Class can be used to warp sequences of pmd depth images into a second view with different parameters, including a different camera center |
| BIAS::Point3DData | Stores data for drawing a point |
| BIAS::PointLightScene | |
| 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::Primitives | Helper class for creating primitives |
| 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::ProjectionError | |
| 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::ProjectionParametersBufferedRay | This class maps image coords to rays which are buffered for fast lookup |
| 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::RenderContextBase | Base for all classes creating interface between GL and "window manager" |
| RenderingState | ! |
| 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::SamplerBinding | Helper to manage the binding of textures to texture units via uniform names |
| BIAS::SamplerBinding::textureCache | |
| BIAS::ScaledImageCanvas | Display float images in wx application, provides zoom, scale, shift and investigation functionality |
| BIAS::ScaleParams | |
| BIAS::ScanLine | Class for scanning a image region given by a line and a distance from the line |
| BIAS::ScanLine2 | |
| BIAS::SceneBase | Base class for all scenes |
| BIAS::SceneBGImage | |
| BIAS::SceneGL | Simple interface for GL calls |
| BIAS::SceneOpenSceneGraph | Implements narrow access to OpenSceneGraph |
| BIAS::ScenePlainOpenSceneGraph | |
| BIAS::SceneText | Wrapping bias::drawtextgl to BIAS::Scene |
| BIAS::SceneTextScreen | Wrapping bias::drawtextgl to BIAS::Scene |
| BIAS::SceneThreeDOutWrapper | Wrapping ThreeDOut OpenGL-functionality |
| BIAS::ScreenShotListener | If KEY_F5 is activated screenshot is stored to given basename + screenshot count |
| SegmentationData | |
| BIAS::SensorData | |
| BIAS::SettingsGL | Application controlled OpenGl renderingsettings |
| BIAS::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(); |
| 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 |
| ShowCamWx | Gui application for image grabbing and from various cameras |
| ShowCamWxApp | |
| BIAS::ShowCamWxFormat7Frame | |
| ShowCamWxFrame | This class is the main frame of the ShowCamWx Application |
| BIAS::ShowCamWxFrame | |
| 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 |
| BIAS::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 |
| BIAS::SimpleMultiPassFragmentShader::ActionGuard | |
| BIAS::SimpleQuad | |
| SimpleSceneGL | JW |
| SimpleSceneGLData | JW |
| BIAS::Singleton< T > | Simple singleton implementation for multithreaded applications |
| BIAS::SMPFSActionInterface | Class allows to add actions different then rendering to the multipass shader execution |
| 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::SparseUmfMatrix | Sparse matrix in compressed column or in triplet form |
| 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::StandardDeviation | |
| 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::TemplateSpecializedBatch | This file contains the header for a class template |
| BIAS::Tensor3D< T > | |
| BIAS::Tensor3D3x3x3< T > | |
| TestArray2D | Test Array 2D MIP |
| TestCompareFloatingPoint | Test comparison of floating point numbers |
| 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 | 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 |
| TestShardesPtr | Test usage of shared pointers |
| TestSparseArray2D | Test sparsely occupied Array2D MIP |
| TestTriangulation | Unit test for Triangulation::TriangulateProjective |
| TestValuePair< T > | |
| BIAS::Texture2DPool | Convenience container for managing 2D textures |
| BIAS::TextureMapping< InputStorageType, OutputStorageType > | Maps source pixel to sink pixel given any TextureTransform |
| BIAS::TextureTransform | Class for representing parameterized image warps, such as homography, displacement, |
| BIAS::TextureTransformAffine | Analytic properties of affine image warp |
| BIAS::TextureTransformDisparity | Analytic properties of x-displacement |
| BIAS::TextureTransformDisplacement | Analytic properties of 2D image displacement |
| BIAS::TextureTransformEuclidian | Analytic properties of Euclidian image warp (rot |
| BIAS::TextureTransformHomography | Analytic properties of homography transformation of an image |
| BIAS::TextureTransformRotation | Analytic properties of rotational image warp (around some point) |
| BIAS::TextureTransformSimilar | |
| BIAS::TFTensorEstimation | Class TFTensorEstimation |
| BIAS::Thinning< InputStorageType, OutputStorageType > | Generic Thinning class |
| ThreadArg__ | |
| BIAS::ThreeDOut | Unified output of 3D entities via OpenGL or VRML |
| BIAS::ThreeDOutOpenSceneGraph | Class for exporting ThreeDOut objects to OSG scene graphs |
| BIAS::ThreeDOutParameters | Configuration struct for drawing styles of various 3d objects |
| BIAS::TimeMeasure | Class TimeMeasure contains functions for timing real time and cpu time |
| BIAS::TimeMeasurement | |
| BIAS::TimeStamp | Holds system time in milliseconds |
| BIAS::TimeStampGen | Generates absolute timestamps with a certain offset from given base-time |
| BIAS::Timing | High resolution HW timers JW |
| TIntersect | |
| BIAS::TrackballBase | Functionality for editing cameras or transformations in trackball mode. parts of trackballcontroler code have been moved to this base class so they can be used in other trackball classes like trackballTransController |
| BIAS::TrackballControl | Class for camera movement in trackball mode |
| BIAS::TrackballTransControl | Class for editing scenegraph transform nodes in trackball mode |
| BIAS::Tracker< StorageType, CalculationType > | High level tracking class |
| TrackerBase | |
| TrackerBase | Devel version of antialiased affine tracker |
| BIAS::TrackerBaseAffine< StorageType > | |
| BIAS::TrackerBaseAffine2< StorageType > | |
| BIAS::TrackerBaseHomography< StorageType > | |
| BIAS::TrackerBaseInterface< StorageType > | Base class for the different tracking algorithms, defining the interfaces for the tracking functions |
| BIAS::TrackerBaseSimple< StorageType > | |
| BIAS::TrackerBaseWeighted< StorageType > | |
| BIAS::TrackerBaseWeighted1D< StorageType > | |
| BIAS::TrackerSynth< StorageType, CalculationType > | Returns ground truth tracks read from file, for debugging |
| BIAS::TransformNode | Interface for transformations edited by a TackballTransControler |
| transparentColourArrayVisitor | |
| transparentColourValueVisitor | |
| TNT::Transpose_View< Array2D > | |
| BIAS::TreeDescr | Container for scene root and ptr to nodeinfomap |
| BIAS::TriangleMesh | The parameter minCornerAngle defines a lower bound on the allowed angle in each triangle |
| BIAS::TriangleMeshSplatRendering | Scene for rendering multiple triangle meshes generated from depth maps |
| BIAS::Triangulation | Class for triangulation of 3Dpoints from 2D matches |
| BIAS::TrifocalTensor | |
| BIAS::TrifocalTensorBase | |
| BIAS::TukeyWindow< InputStorageType, OutputStorageType > | Multiplies an image with a full image size tukey window |
| BIAS::UDPClient | |
| UDPDataConsumer | |
| BIAS::UDPServer | |
| BIAS::UncertaintyTransformBase | Base class for all uncertainty transforms |
| BIAS::UndistortionMapping< InputStorageType, OutputStorageType > | Maps image src to image sink with spherical or lens distortion |
| TNT::UnitLowerTriangularView< MaTRiX > | |
| TNT::UnitUpperTriangularView< MaTRiX > | |
| BIAS::UnscentedTransform | Uses the unscented transformation to map a normal distribututed random variable using a nonlinear transformation |
| BIAS::UnVignette | Unvignette algorithm for images |
| TNT::UpperTriangularView< MaTRiX > | |
| uta | Some derive class |
| BIAS::UUID | Interface class for producing/storing Universally Unique IDentifiers |
| BIAS::UUIDsortAscending | Helper class for ascending sort of sequential BIAS::UUIDs Sample usage: |
| Vardesc | |
| BIAS::VecOMapOStrDbl | Needed for WIN32-DLL, templates of templates |
| BIAS::Vector< T > | Class for column vectors with arbitrary size |
| TNT::Vector< T > | |
| BIAS::Vector2< T > | Class Vector2 contains a Vector of dim |
| BIAS::Vector3< T > | Class Vector3 contains a Vector of fixed dim |
| BIAS::Vector4< T > | Class Vector4 contains a Vector of dim |
| TNT::Vector_Adaptor< BBVec > | |
| BIAS::VectorPanel | Panel for displaying and editing vectors |
| Vertex | |
| BIAS::VideoServer | Class to send images from a camera or disk to a client |
| BIAS::VideoShMFeeder | Class to save Images to a Sharerd memory |
| BIAS::VideoShMFeederPMD | Class to save Images to a Sharerd memory |
| BIAS::VideoSink | |
| BIAS::VideoSource | Defines a common interface to different devices |
| BIAS::VideoSource_Controller | |
| BIAS::VideoSource_Controller_PMD | |
| BIAS::VideoSource_Controller_SwissRanger | |
| BIAS::VideoSource_Controller_usbPMD | |
| BIAS::VideoSource_Controller_XB3 | |
| BIAS::VideoSource_DCAM | This class VideoSource_DCAM implements access to IEEE1394 (Firewire, iLink) cameras following the DCam 2.0 standard protocol |
| BIAS::VideoSource_DCAM_XB3 | |
| BIAS::VideoSource_DcamPMD | |
| BIAS::VideoSource_Disk | This class simulates a video device by loading images from disk |
| BIAS::VideoSource_Disk_Bayer | |
| BIAS::VideoSource_DiskPMD | |
| BIAS::VideoSource_DiskZessPMD | Reads images from three image lists with 2d images, depth images and modulation coefficients |
| BIAS::VideoSource_DSHOW | This class extends VideoSource for the use of DirectShow devices |
| BIAS::VideoSource_DV | This class extends VideoSource for the use of IEEE1394-connected DV-camcorders |
| BIAS::VideoSource_DV2 | This class extends VideoSource for the use of IEEE1394-connected DV-camcorders |
| BIAS::VideoSource_Net | This class implements a video streaming client using TCP |
| BIAS::VideoSource_PMD | Support for CamCube usb cam |
| BIAS::VideoSource_Shm | This class implements a video streaming client using shared memory to receive images from another application |
| BIAS::VideoSource_Shm::ShmImageHeader | |
| BIAS::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 |
| BIAS::VideoSource_Stereo | |
| BIAS::VideoSource_SwissRanger | Support for SwissRanger usb cam |
| BIAS::VideoSource_uEye | |
| VideoSource_UEYE | This class extends VideoSource for the use of IDS UEYE devices |
| BIAS::VideoSource_usbPMD | |
| BIAS::VideoSource_V4L | This class extends VideoSource for the use of Video4Linux supported devices like framegrabber, USB cameras |
| BIAS::VideoSource_V4L::buffer | |
| BIAS::VideoSourceCapabilities | |
| BIAS::VideoSourceCapabilities::VSCapEntry | |
| BIAS::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 |
| BIAS::VideoStream::VSHeader | |
| BIAS::VideoStream::VSImageHeader | |
| VideSource_DcamPMD | Reads PMD-tiffs with depth images and modulation coefficients |
| VideSource_DiskPMD | Reads PMD-tiffs with depth images and modulation coefficients |
| VideSource_PMD2D3D | Reads standardPMD-tiffs(2D) with depth images and modulation coefficients TODO: include support for normal images (2DImg_), not supported by prototype |
| VideSource_Stereo | Bundles two video sources for stereo |
| BIAS::View | A view is a rectangular part of a render context in which a set of scenes is rendered using a GLProjection |
| BIAS::WeightedSigmaPoint | |
| BIAS::WrapBias2Ipl | Wrapper around a BIAS image to be used as an OpenCv IPlimage with shared data area |
| BIAS::wxMessageDialogCheckbox | |
| wxScrolledWindow | |
| BIAS::WxToAsciiArray | Class for converting an array of wxStrings to an array of non-const ASCII strings |
| wxTopLevelWindow | |
| wxTopLevelWindowNative | |
| wxWindow | |
| BIAS::XMLBase | Base class with interface for xml output |
| BIAS::XMLIO | Wrapper class for reading and writing XML-Files, based on the XML-library 'libxml2' |
| xvimage | |
| BIAS::ZoomFrame | Used by ImageCanvas and ScaledImageCanvas, should not be used directly |
| BIAS::ZoomImageCanvas |
1.5.6