# Class List

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

apmatrix< itemType > |
apvector< itemType > |
boost::numeric::bindings::traits::matrix_detail_traits< opentl::math::Matrix, M > |
boost::numeric::bindings::traits::matrix_detail_traits< opentl::math::SquareMatrix, M > |
boost::numeric::bindings::traits::matrix_detail_traits< opentl::math::Transform, M > |
boost::numeric::bindings::traits::vector_detail_traits< opentl::math::Vector, V > |
boost::numeric::bindings::traits::vector_detail_traits< opentl::math::Vector2, V > |
boost::numeric::bindings::traits::vector_detail_traits< opentl::math::Vector3, V > |
boost::numeric::bindings::traits::vector_detail_traits< opentl::math::Vector4, V > |
boost::numeric::bindings::traits::vector_detail_traits< opentl::math::Vector6, V > |
CCameraImage |
CImageSet |
CImageSetView |
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
HoughLines::HoughLines::opentl | Class for Hough Lines feature modality computation
ImageDevice | Abstract base class for any sensor devices
ImageDevice | Abstract base class for image devices
Mat44 |
MatchPair |
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::HoughLines | Class for storing a vector of Hough Lines data: Segment Points in body frame (bp) Segment Points in image frame (sp) middle point (spm) Slope of the segment (m) Slope of the normal (mn) length of the segment (le)
opentl::core::cvdata::HoughLines::HoughLines::HSEGMENT | Stores the coordinates of hough segments points in body space & image space, also stores the hough lines data
opentl::core::cvdata::Image | Class for Image Storage
opentl::core::cvdata::LucasKanadeFeatures | Provides a Container for the Lucas Kanade Features
opentl::core::cvdata::PointCloud3D | Class to store 3D points gained from Range Finders, Depth Cameras like the Videre STOC or from triangulation
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::Pose2dDeformableMesh | Implemented class for storing 2D/3D multi-part object with synchronized motion
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::Pose3dRotoXYTranslation | Implemented class for storing 3D solid object related rotation with Euler angles and translation transformation data limiting the rotation to X and Y axes only. T is 4x4 matrix
opentl::core::cvdata::Pose3dRotoXZTranslation | Implemented class for storing 3D solid object related rotation with Euler angles and translation transformation data limiting the rotation to X and Z axes only. T is 4x4 matrix
opentl::core::cvdata::Pose3dRotoYZTranslation | Implemented class for storing 3D solid object related rotation with Euler angles and translation transformation data limiting the rotation to Y and Z axes only. T is 4x4 matrix
opentl::core::cvdata::Pose3dRotoZTranslation | Implemented class for storing 3D solid object related rotation with Euler angles and translation transformation data limiting the rotation to Z axes only. T is 4x4 matrix
opentl::core::cvdata::Pose3dTranslation | Implemented class for storing 3D pose parameters (only translation)
opentl::core::cvdata::PoseArticulated | Implemented class for storing 2D/3D articulated and multi-part objects
opentl::core::cvdata::PoseFactory |
opentl::core::cvdata::PoseMultiPartSynchronous | Implemented class for storing 2D/3D multi-part object with synchronized motion
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::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::SurfFeatures |
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. a single measurement structure is related to: 1 target, 1 modality (hence also 1 camera), and 1 thread
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::FootprintParser |
opentl::core::parser::HalconFile |
opentl::core::parser::MatrixFile |
opentl::core::parser::PlainFileParser |
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::ExpFilter< _T > |
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::SD_GroundTruth | Class for reading and writing XML based ground truth data and configuration settings for generating this data
opentl::core::util::SD_math_transform | Wrapper class around math::Transform for data serialization
opentl::core::util::SD_math_vector | Wrapper class around math::Vector for data serialization
opentl::core::util::SD_ShapeAppearance | Wrapper class around core::cvdata::ShapeAppearance for data serialization
opentl::core::util::SerializedData | Base class for serialized data exchange. All classes/structures with data to be serialized should be derived from this class. Based on Boost serialization classes
opentl::core::util::StorageMgr |
opentl::core::util::TCPClient |
opentl::core::util::TCPServer |
opentl::core::util::Timer |
opentl::core::util::TypeConversion |
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::BackgroundFgSub |
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! number of mixtures is limited!! ( 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 color histogram of an image, inside a specific ROI, and under a specific binary mask (shadow)
opentl::cvprocess::ColorHistShader::ColorHistShader::Param |
opentl::cvprocess::ColorHistSum | This is a shader example for computing a histogram out of partial histogram (by simply summing them, bin per bin) NOTE: Derived class from GpuStdShaders
opentl::cvprocess::ColorHistSum::ColorHistSum::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::DisparityMapGPU | Class for computing the disparity map of two stereo images
opentl::cvprocess::EdgeMap |
opentl::cvprocess::FaceDetect |
opentl::cvprocess::FASTFeatureDetector | This class computed the "Features from Accelerated Segment test" corners detectN: N is the number of pixels on the circle, which have to have the same pixel value as the center : grayscale image
opentl::cvprocess::FisherColor |
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::OpticalFlow |
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::OrientedDT | Class for computing the oriented distance transform
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::SurfFeatures |
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::PolyhedronSampler |
opentl::detector::PeopleDetector |
opentl::detector::PeopleDetector::PeopleDetector::Param | Parameters for detection
opentl::input::AbstractSensor |
opentl::input::CameraCalibration |
opentl::input::FileSequence |
opentl::input::FirewireCamera | Interface class with factory functions for Firewire cameras
opentl::input::GPSSensorFile |
opentl::input::ImageSensor |
opentl::input::ImageSequence |
opentl::input::InputException |
opentl::input::LinuxDC1394Camera | Concrete class implementing the Camera interface for Firewire cameras
opentl::input::OdometrySensorFile |
opentl::input::OpenCVCamera | Interface class for using OpenCV to access (USB,...) cameras
opentl::input::V4L2Camera | Interface class for using V4L2 API to access (USB,...) cameras
opentl::input::VideoFile | Class to capture images from a video file
opentl::input::WindowsCMU1394Camera | Concrete class implementing the Camera interface for Firewire cameras
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 | GPU-based foreground/background segmentation modality
opentl::modalities::Blobs |
opentl::modalities::CCDCore |
opentl::modalities::CChebSeries |
opentl::modalities::ColourGMMGPU |
opentl::modalities::ColourHist2D |
opentl::modalities::ContourCCD |
opentl::modalities::DataFusion | Static data fusion class. It inherits from the modalities:Modality interface, so it can be flexibly combined with the features. ASSUMPTIONS: the children output levels of one DataFusion class instance must be of the same level E.g. if you want to fuse the output of two pixel level children and one feature level child you have to cascade two DataFusion classes. DF1 instance fuses pixel level to feature level and DF2 instance fuses the output of DF1 with the feature level child
opentl::modalities::DummyModality |
opentl::modalities::HarrisKeypoints |
opentl::modalities::HarrisKeypoints::HarrisKeypoints::HarrisKeyframe | A key-frame contains: an image, and its filtered version (for NCC matching) the annotated pose of the visible target (NOTE: only one target per keyframe!) the detected (and back-projected) Harris keypoints
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::HoughLines |
opentl::modalities::IntensityEdges | 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::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::OpticalFlow |
opentl::modalities::SurfFeatures |
opentl::modalities::SurfFeatures::SurfFeatures::SURFKeyframe |
opentl::modalities::TemplateMap | Processing functions related to the template visual feature (cvdata::TemplateMap)
opentl::modelprojection::ContourSampler | Class for doing object feature visability checks in the context of a OpenGL scene with all targets displayed
opentl::modelprojection::ContourSampler::ContourSampler::ShapeData_t | Structure for storing object model related shape appearance data required for fast contour sampling
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::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: the prior/posterior state distribution (pdf) in form of a Gaussian (mean and covariance matrix) or a particle set a pointer to the ObjModel the unique ID of this target instance
opentl::models::TargetFactory | Class to create new target instances based on a given model
opentl::output::Branding |
opentl::output::Display |
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::output::SerialPort |
opentl::output::video::VideoWriter_Backend |
opentl::output::video::VideoWriter_FFmpeg |
opentl::output::video::VideoWriter_OpenCV |
opentl::output::video::VideoWriter_QuickTime |
opentl::output::VideoWriter |
opentl::tracker::DummyTracker |
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 |
rational |
Serialize | Abstract class for data serialization. TODO: make it a Singelton!
Vec3f |
Vec4f |
Vertex |
xy |