| COLLADParser | Class to fully scan a COLLADA document |
| ContourCCD::ContourCCD::opentl | Class for contour-based tracking using the CCD method |
| CreateByType | Class to create new class instances based on a given type |
| CreateByType | Class to create new class instances based on a given type |
| ImageDevice | Abstract base class for image devices |
| ImageDevice | Abstract base class for any sensor devices |
| Modality::Modality::opentl | Top level abstraction class for visual feature processing |
| opentl::core::cvdata::Blobs | |
| opentl::core::cvdata::Blobs::Blobs::BlobInfo | |
| opentl::core::cvdata::ColorGMM | |
| opentl::core::cvdata::ColourHist2d | |
| opentl::core::cvdata::CvData | |
| opentl::core::cvdata::GM | |
| opentl::core::cvdata::HarrisKeypoints | |
| opentl::core::cvdata::HarrisKeypoints::HarrisKeypoints::HarrisInfo | This class hosts information about a single Harris keypoint (position, descriptor etc.) |
| opentl::core::cvdata::Image | Class for Image Storage |
| opentl::core::cvdata::Pose | Abstract class for storing object related value data |
| opentl::core::cvdata::Pose2d1ScaleRotoTranslation | Implemented class for storing 2D solid object related transformation data with 4 DOF (scale, rotation, translation x, translation y) |
| opentl::core::cvdata::Pose2d1ScaleTranslation | Implemented class for storing 2D solid object related transformation data with 3 DOF (scale, translation x, translation y) |
| opentl::core::cvdata::Pose2d2ScaleRotation | Implemented class for storing 2D solid object related transformation data with 3 DOF (2xscale, rotation) |
| opentl::core::cvdata::Pose2d2ScaleRotoTranslation | Implemented class for storing 2D solid object related transformation data with 5 DOF (2xscale, rotation, translation x, translation y) |
| opentl::core::cvdata::Pose2d2ScaleTranslation | Implemented class for storing 2D solid object related transformation data with 4 DOF (2xscale, translation x, translation y) |
| opentl::core::cvdata::Pose2dAffine | Implemented class for storing 2D solid object related affine (translation, rotation, scale) transformation data |
| opentl::core::cvdata::Pose2dHomography | Sets 2d homography transformation matrix from parameter vector. _y =H(p)x; y = screen coordinates |
| opentl::core::cvdata::Pose2dRotation | Implemented class for storing 2D solid object related transformation data with 1 DOF |
| opentl::core::cvdata::Pose2dRotoTranslation | Sets transformation matrix from 2d roto translation vector. y=H(p)x; y = screen coordinates In order to be compatible to x in 3d homogeneous coordinates H is 4x4 matrix |
| opentl::core::cvdata::Pose2dTranslation | Implemented class for storing 2D solid object related transformation data with 2 DOF |
| opentl::core::cvdata::Pose3dEulerRotation | Implemented class for storing 3D solid object related rotation with Euler angles. T is 4x4 matrix |
| opentl::core::cvdata::Pose3dEulerRotoTranslation | Implemented class for storing 3D solid object related rotation with Euler angles and translation transformation data. T is 4x4 matrix |
| opentl::core::cvdata::Pose3dPlanarRotoTranslation | Implemented class for storing 3D solid object motion on a plane (3 dof) T is 4x4 matrix |
| opentl::core::cvdata::Pose3dProjective | Sets 3d projection matrix from parameter vector. ATTENTION: direct transformation from body to screen space (extrinsic+intrinsic!) y=H(p)x |
| opentl::core::cvdata::Pose3dRotationXaxis | Implemented class for storing 1-axis rotation pose (axis = x). T is 4x4 matrix. Vector1[0] = alpha (in rad) |
| opentl::core::cvdata::Pose3dRotationXYaxis | Implemented class for storing 3D solid object related rotations around x and y axis. T is 4x4 matrix |
| opentl::core::cvdata::Pose3dRotationYaxis | Implemented class for storing 1-axis rotation pose (axis = y). T is 4x4 matrix. Vector1[0] = alpha (in rad) |
| opentl::core::cvdata::Pose3dRotationZaxis | Implemented class for storing 1-axis rotation pose (axis = z). T is 4x4 matrix. Vector1[0] = alpha (in rad) |
| opentl::core::cvdata::Pose3dTranslation | Implemented class for storing 3D pose parameters (only translation) |
| opentl::core::cvdata::Pose3dTwist | Implemented class for storing 3D solid object related value data in twist vector representation |
| opentl::core::cvdata::PoseArticulated | Implemented class for storing 2D/3D articulated and multi-part objects |
| opentl::core::cvdata::PoseFactory | |
| opentl::core::cvdata::ShapeAppearance | Class for storing the shape and appearance information of an object |
| opentl::core::cvdata::ShapeAppearance::ShapeAppearance::Edge | Structure for an edge |
| opentl::core::cvdata::ShapeAppearance::ShapeAppearance::EdgeReferredByFace | Structure to hold geometric information about faces this edge is part of |
| opentl::core::cvdata::ShapeAppearance::ShapeAppearance::Face | Structure for a face |
| opentl::core::cvdata::ShapeAppearance::ShapeAppearance::Material | |
| opentl::core::cvdata::ShapeAppearance::ShapeAppearance::Point | |
| opentl::core::cvdata::ShapeAppearance::ShapeAppearance::TexCoord | |
| opentl::core::cvdata::SiftFeatures | |
| opentl::core::cvdata::SiftFeatures::SiftFeatures::siftInfo | |
| opentl::core::cvdata::Skeleton | Abstract class for storing object related valuee data |
| opentl::core::cvdata::Skeleton::Skeleton::T_SKEL_NODE | Node structure for the skeleton tree |
| opentl::core::cvdata::T_MEAS_FEAT | Structure holding a single feature-level measurement. A single measurement is related to: 1 target, 1 modality, 1 camera, 1 thread |
| opentl::core::cvdata::T_MEAS_LIK | Structure holding the output, explicit measurement data, collected by the likelihood class.
|
| opentl::core::cvdata::T_MEAS_OBJ | Structure holding a single object-level measurement. A single measurement is related to: 1 target, 1 modality, 1 camera, 1 thread |
| opentl::core::cvdata::T_MEAS_PIX | Structure holding a single pixel-level measurement. A single measurement is related to: 1 target, 1 modality, 1 camera, 1 thread |
| opentl::core::cvdata::TemplateMap | |
| opentl::core::cvdata::TemplateMap::TemplateMap::TMAPFEATURE | Model Feature (obj. position + 2 descriptors + warped pos. + visibility) |
| opentl::core::cvdata::TextureGpu | Class for storing GPU texture related management information |
| opentl::core::cvdata::TiledImage | |
| opentl::core::cvdata::TimedData | |
| opentl::core::cvdata::VisContourSamplePts | Class for storing the body space countour sample points edge-wise (edge-wise data storage avoids the usage of companion point indices and eases RANSAC usage) |
| opentl::core::cvdata::VisContourSamplePts::VisContourSamplePts::CPOINT | Stores the coordinates of visible edge sample points in body space + companion point index |
| opentl::core::cvdata::VisContourSamplePts::VisContourSamplePts::Edge | Stores the indices of one inlier measurement related to CPOINT structure |
| opentl::core::cvdata::VisualFeatures | |
| opentl::core::Exception | OpenTL basic Exception class for wrapping around std::exception |
| opentl::core::parser::CmdLineParser | Class for parsing the command line arguments |
| opentl::core::parser::COLLADAParser | |
| opentl::core::parser::XMLParser | Class to fully scan a xml document |
| opentl::core::parser::XMLParser::XMLParser::TagInfo | |
| opentl::core::parser::XMLParser::XMLParser::Token | |
| opentl::core::parser::XMLParser::XMLParser::XMLTag | |
| opentl::core::State | Class for storing object related state data |
| opentl::core::SystemManager | |
| opentl::core::TrackingData | Abstract class for data required by tracking algorithm (SensorData, Measurement, State) |
| opentl::core::util::AbstractParameter | |
| opentl::core::util::Filesystem | |
| opentl::core::util::GaussNewton | Gauss-Newton optimization. This class implements a single Gauss-Newton optimization step for nonlinear least-squares problems. For efficiency reasons, it uses cached data structures, related to the measurement size, and the number of pose degrees of freedom |
| opentl::core::util::GaussNewton::GaussNewton::GaussNewtonData_Key_dof | |
| opentl::core::util::GaussNewton::GaussNewton::GaussNewtonData_Key_dof_and_featSize | Structure for caching individual GN-terms (single features). key = pose dof (left 16bits) AND feature size (right 16bits) |
| opentl::core::util::OfflineParameter< T > | |
| opentl::core::util::OnlineParameter< T > | |
| opentl::core::util::ParameterContainer | |
| opentl::core::util::Resources | |
| opentl::core::util::RingBuffer< _T > | |
| opentl::core::util::StorageMgr | |
| opentl::core::util::Timer | |
| opentl::core::util::TypeConversion | |
| opentl::core::Watermark | |
| opentl::cvprocess::And | Executes And operation on 2 (binary) input textures (separate for each channel) Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! |
| opentl::cvprocess::BackgroundSub | |
| opentl::cvprocess::BackgroundSub::BackgroundSub::Param | Parameters for visual processing in this class |
| opentl::cvprocess::Bayer | |
| opentl::cvprocess::BayerRG2GRAY | GPU based debayering. Derived class from GpuStdShaders. Bi-linear debayering with edge sensitivity based on paper "fast demosaic by frequency replacement" Output format is a single channel grayscale texture |
| opentl::cvprocess::BayerRG2RGB | GPU based debayering. Derived class from GpuStdShaders. Bi-linear debayering with edge sensitivity based on paper "fast demosaic by frequency replacement" Output format is RGB texture |
| opentl::cvprocess::BGR2GRAY | BGR to Grayscale conversion. Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::BGR2HSV | BGR to HSV conversion. Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::Classify | Selects the highest value of e.g. segmented textures texture1 --> likelihood class 1 texture2 --> likelihood class 2 Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! |
| opentl::cvprocess::ColorGMM | Color segmentation filter using Gaussian Mixture Modells. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::ColorGMM2 | Color segmentation filter using Gaussian Mixture Modells. usable for 2 dimensional color mixtures (e.g. H and S channel only) NOTES: -GMM values are for color ranges between 0 and 255!
maximum number of gmms (classes) is limited!! ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::ColorGMM::ColorGMM::Param | |
| opentl::cvprocess::ColorHistShader | This is a shader example for computing the JOINT HISTOGRAM between a template set of model points (grey values) and the corresponding grey values at projected camera locations. The histogram can be used for computing mutual information
|
| opentl::cvprocess::ColorHistShader::ColorHistShader::Param | |
| opentl::cvprocess::ColourDetector | |
| opentl::cvprocess::ColourDetector::ColourDetector::Param | Public struct definition******************************* |
| opentl::cvprocess::ColourHist2D | |
| opentl::cvprocess::CV | |
| opentl::cvprocess::CvtColour | |
| opentl::cvprocess::DebugUInt2Float | Shader for debugging: allows to convert an unsigned int texture to float OR display the texture on the screen. Derived class from GpuStdShaders. ATTENTION: This TEMPLATE filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! -> pay attention what kind of texture sampler type is used in the shader code |
| opentl::cvprocess::FaceDetect | |
| opentl::cvprocess::FlipV | Flip texture vertically. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::GlFbo | |
| opentl::cvprocess::GlShaderMgr | Class for managing GPU shader code (GLSL). Uses singleton pattern to avoid duplicate allocation of program and shader code objectModels |
| opentl::cvprocess::GpuStdShaders | Abstract base class for standard shader operations on the GPU. Add actual standard shader implementations by deriving this class. See 0_Template.h as an example |
| opentl::cvprocess::GRAY2Sobel | GRAY2Sobel filter. Applies a horizontal and vertical Sobel filter to a grayscale texture. Resulting texture channel values: .r = hEdge , .g = vEdge, b = norm(sobelHV) The resulting texture must support signed values and have double number of bits per channel |
| opentl::cvprocess::Grayscale | Color to Grayscale filter. Derived class from GpuStdShaders. ATTENTION: This TEMPLATE filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! -> pay attention what kind of texture sampler type is used in the shader code |
| opentl::cvprocess::Grayscale::Grayscale::Param | |
| opentl::cvprocess::Laplacian | Laplacian filter. Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::Laplacian::Laplacian::Param | |
| opentl::cvprocess::Moments | |
| opentl::cvprocess::MotionSegment | |
| opentl::cvprocess::NonMaxSupression | Non maximum supression filter. Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::NonMaxSupression::NonMaxSupression::Param | |
| opentl::cvprocess::Not | Executes Not operation on 2 (binary) input textures (separate for each channel) Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! |
| opentl::cvprocess::Not::Not::Param | |
| opentl::cvprocess::Or | Executes Or operation on 2 (binary) input textures (separate for each channel) Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! |
| opentl::cvprocess::Or::Or::Param | |
| opentl::cvprocess::PixelCount | Computes the sum of all white(value == 255) pixels Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::RGB2GRAY | RGB to Grayscale conversion. Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::RGB2HSV | RGB to HSV conversion. Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only |
| opentl::cvprocess::Subtract | Executes Subtract operation on 2 input textures Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! |
| opentl::cvprocess::Xor | Executes Xor operation on 2 input textures --> subtracts 2 textures and sets the pixel to ZERO if negative Derived class from GpuStdShaders. ATTENTION: This filter works with a source texture of type GL_TEXTURE_RECTANGLE_ARB only! |
| opentl::detector::BlobDetector | |
| opentl::detector::Detector | Abstract base class for all detectors to come |
| opentl::detector::DetectorException | |
| opentl::detector::HandDetector | |
| opentl::detector::HandDetector::HandDetector::Param | |
| opentl::detector::ParticleDetector | |
| opentl::detector::ParticleDetector::ParticleDetector::Param | Parameters for detection |
| opentl::input::AbstractSensor | |
| opentl::input::FileSequence | |
| opentl::input::FirewireCamera | Interface class with factory functions for Firewire cameras |
| opentl::input::ImageSensor | |
| opentl::input::InputException | |
| opentl::input::LinuxDC1394Camera | Concrete class implementing the Camera interface for Firewire cameras |
| opentl::input::OpenCVCamera | Interface class for using OpenCV to access (USB,...) cameras |
| opentl::input::VideoFile | Class to capture images from a video file |
| opentl::math::CV | |
| opentl::math::Math | Class supporting basic mathematical routines |
| opentl::math::Matrix | Matrix class for matrix operations. This class is based on opencv matrix class |
| opentl::math::SquareMatrix | Special matrix class for a square matrix, |
| opentl::math::Transform | Special class for a homogeneous transformation matrix |
| opentl::math::Units | |
| opentl::math::Vector | Class for Vector |
| opentl::math::Vector2 | Special class for vectors with dimension of two |
| opentl::math::Vector3 | Special class for vectors with dimension of three |
| opentl::math::Vector4 | Special class for vectors with dimension of four |
| opentl::math::Vector6 | Special class for vectors with dimension of six |
| opentl::modalities::BackgroundSub | Foreground/background segmentation modality |
| opentl::modalities::CCDCore | |
| opentl::modalities::CChebSeries | |
| opentl::modalities::ColourGMMGPU | |
| opentl::modalities::ColourHist2D | |
| opentl::modalities::ContourCCD | |
| opentl::modalities::ContourPointsGPU | Class for contour point feature modality computation. ATTENTION: This class is currently not prepared for multi-threaded match...Level() calls related to a single sensor index! |
| opentl::modalities::DataFusion | Static data fusion class. It inherits from the modalities:Modality interface, so it can be flexibly combined with the features. ASSUMPTIONS:
|
| opentl::modalities::HarrisKeypoints | |
| opentl::modalities::HarrisKeypoints::HarrisKeypoints::HarrisKeyframe | A key-frame contains:
|
| opentl::modalities::HistoOrientedGrad | Visual modality: Histogram of Oriented Gradients (HOG) This class implements the HOG on a reference pattern, to be matched to the current image It uses the integral HOG in order to speed up computations for multiple evaluations (e.g. particle filters) on a rectangular bounding box at a given pose |
| opentl::modalities::Likelihood | Class for likelihood evaluations |
| opentl::modalities::Likelihood::Likelihood::T_LIK_MODALITY_FEATURE | Internal structure for storing the child modality information on feature level |
| opentl::modalities::Likelihood::Likelihood::T_LIK_MODALITY_OBJECT | Internal structure for storing the child modality information on object level |
| opentl::modalities::Likelihood::Likelihood::T_LIK_MODALITY_PIXEL | Internal structure for storing the child modality information on pixel level |
| opentl::modalities::ModalitiesException | |
| opentl::modalities::Modality | |
| opentl::modalities::Motion | |
| opentl::modalities::TemplateMap | Processing functions related to the template visual feature (cvdata::TemplateMap) |
| opentl::modelprojection::GLRenderer | Class for OpenGL based output to screen or other virtual devices |
| opentl::modelprojection::GLScene | Class OpenGL scene creates the OpenGL context, initializes display lists per objectModel and creates a FBO management and Shader management instance |
| opentl::modelprojection::ModelProjectionException | |
| opentl::modelprojection::PoseEstimation | Pose estimation from point correspondences. This class implements pose estimation from point and/or line correspondences. It uses a two-step procedure: 1 - Initialize pose parameters, using initPose methods from the Pose abstraction 2 - Runs (if required) a Gauss-Newton nonlinear optimization, in order to refine the estimate |
| opentl::modelprojection::VisibilityCheck | Class for doing object feature visability checks in the context of a OpenGL scene with all targets displayed |
| opentl::modelprojection::VisibilityCheck::VisibilityCheck::ShapeData_t | Structure for storing object model related shape appearance data required for fast visibility calculation |
| opentl::modelprojection::Warp | Class for calculating and executing the projection (extrinsic and intrinsic transformation) from object body to 2D camera (sensor) space |
| opentl::modelprojection::WarpBack | |
| opentl::models::Brownian | Implemented class Continuous White Noise Acceleration (CWNA) motion model |
| opentl::models::ConstantVelocity | Implemented class Continuous White Noise Acceleration (CWNA) motion model |
| opentl::models::LinearARModels | Implemented class Continuous White Noise Acceleration (CWNA) motion model |
| opentl::models::Motion | Abstract class for object motion models |
| opentl::models::MotionFactory | |
| opentl::models::ObjModel | Class for storing (generic/specific) object model data for the targets to be tracked. The object models are linked to the tracks/targets by using an object model pointer within a state |
| opentl::models::Oscillatory | Implemented class Continuous White Noise Acceleration (CWNA) motion model |
| opentl::models::Target | Class representing a unique target instance It contains:
|
| opentl::output::Branding | |
| opentl::output::File | |
| opentl::output::LossDetect | Class for OpenGL based output to screen or other virtual devices |
| opentl::output::LossDetect::LossDetect::Param | |
| opentl::output::Output | |
| opentl::output::OutputException | |
| opentl::tracker::InfoFilter | |
| opentl::tracker::InfoFilter::InfoFilter::InfoFilterData | |
| opentl::tracker::Kalman | |
| opentl::tracker::Kalman::Kalman::KalmanData | |
| opentl::tracker::MCMCParticle | |
| opentl::tracker::MCMCParticle::MCMCParticle::Param | |
| opentl::tracker::SIRParticle | |
| opentl::tracker::Tracker | Abstract base class for all trackers to come |
| opentl::tracker::TrackerException | |
| opentl::tracker::UnscentedInfoFilter | |
| opentl::tracker::UnscentedInfoFilter::UnscentedInfoFilter::UnscentedInfoFilterData |
1.5.8