LTI-Lib latest version v1.9 - last update 10 Apr 2010

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
lti::absoluteValue< T >AbsoluteValue functor class
lti::MLP::activationFunctorParent class for all activation function functors
lti::stdLayer::activationFunctorParent class for all activation function functors
lti::activeShapeModelThis is the base class for active shape models (ASM)
lti::adaptiveKMeansThis class implements a k-means clustering that determines the number of clusters by itself
lti::addScalar< T >AddScalar functor class
lti::adjacencyGraph< N, W, D, F, E >Adjacency Graph
lti::adjacencyGraphVoidWeightFunction< N, W, D >Dummy weigh functor that returns the default weight type
lti::allocExceptionAllocException is thrown if a memory allocation problem occurs
lti::andoKernelXX< T >Two-dimensional separable filter kernels for the second derivative approximation
lti::andoKernelXY< T >Two-dimensional separable filter kernels for the second derivative approximation
lti::andoKernelYY< T >Two-dimensional separable filter kernels for the second derivative approximation
lti::arctanLUTFollowing class provides a mono-state object that contains a 1MB Look-up Table to accelerate the computation of the arc-tangens
lti::areaPointsContour classes: Area-Points
lti::array< T >Array class
lti::ascii85CodecEncodes a byte array to an array of hexadecimal digits or performs the corresponding decoding method, depending on the parameters
lti::asciiHexCodecEncodes a byte array to an array of hexadecimal digits or performs the corresponding decoding method, depending on the parameters
lti::asymmetricEdgeTraits< W >Basic class for asymmetric edges
lti::axLocalRegionsThis functor is based on concepts described in Lowe, D.G
lti::axOGDFeatureOGD based texture feature
lti::backgroundModelImplementation of an part of the paper 'Pfinder: Real-Time Tracking of the Human Body' from Wren, Azarbayejani, Darrell and Pentland published in IEEE PAMI July 1997, vol 19, no 7, pp
lti::backSubstitution< T >Backsubstitution
lti::baggingImplementation of bagging classification
lti::microEnablePulnix::bankTypeThe Pulnix Camera TMC6700 can handle up to four parameters sets
lti::battleLemarieKernelBattle-Lemarič filter kernel
lti::bayerDemosaicingThis functor makes a color interpolation of common BAYER Patterns used in digital cameras
lti::bhattacharyyaDistanceComputes the bhattacharyya distance of two distributions
lti::bhattacharyyaDistOfSubsetThe class implements the bhattacharyya distance as cost function
lti::bicubicInterpolator< T >This functor use bicubic interpolation to approximate values between the pixels or elements of vectors and matrices
lti::bilinearInterpolator< T >This functor use bilinear interpolation to approximate values between the pixels or elements of vectors and matrices
lti::binarizationCodecEncodes a byte array to an array of bits
lti::binaryStreamHandlerBinary stream handler
lti::binomialDistributionThis functor implements the binomial distribution
lti::biquadraticInterpolator< T >This functor use biquadratic interpolation to approximate values between the pixels or elements of vectors and matrices
lti::blobEMEstimates the position of M overlapping blobs by applying the EM-algorithm and estimating the parameters of a gaussian mixture model that fits the blobs
lti::blueScreenThis functor replaces a specified background color of an image with another color or another image ("Bluescreen Technique")
lti::borderExtremaThis functor extracts minimum and maximum positions along a border in terms of distance to a given center point
lti::borderPointsContour classes: Border-Points
lti::borderSignatureThis functor extracts a functional border description from a borderPoint list
lti::boundingBox< T >Generate an image containing a region of another one specified through a contour-instance, or compute the "best" rectLocation that contains the specified region
lti::boundsFunctor< T >Boudaries of a hyperbox enclosing all points of a n-dimensional space
lti::boxSide< T >Policy class to compute the size of a box's side and the inverse transformation
lti::brightRGBThis functor splits an image into its three channels (R.G,b) and then calculates the Minimum, Maximum, Average, Median or Average and Variance over their values, depending on the parameter type
lti::dataTransformer::bufferThe buffers with the data to be transformed (or the transformed data) are manipulated in container instances of the buffer type
lti::fireWireDCAM::busInfoIEEE 1394 Bus Information Class
lti::calibrationBlobFeaturesTo calibrate the camera optic feature points of an calibration pattern must be extracted
lti::cameraParent class for all cameras with control over the lens system, including zooming
lti::fireWireDCAM::cameraInfoThe camera information class
lti::fireWireDCAM::cameraSetSet of cameras
lti::camshiftTrackerThis is the implementation of the CAMSHIFT (Continuously Adaptive Mean Shift) Tracking algorithm as described in: G.Bradski, "Computer Vision Face Tracking For Use in a Perceptual User Interface", IEEE Workshop on Applic.Comp.Vis.,1998
lti::cannyEdgesThe Canny Edge Detector is a standard algorithm, designed to detect "optimal" edges
lti::cartesianToPolar< T >Computes the elements of the polar coordinate system (value,phase) based on the parameters of the cartesian coordinate system (x,y)
lti::centroidClusteringBase class for all clustering methods that use centroids or prototypes for describing individual clusters
lti::chainCodeElements of a Chaincode
lti::channelFormat for float channels
lti::channel32Format for signed 32-bit-channels
lti::channel8Format for 8-bit-channels
lti::channelStatisticsThis functor splits an image into three channels of a color space set in the parameters (see parameters::setSplitter() )
lti::rgbPixel::rgbPixelType::channelsTypeThree channels
lti::chessBoardKernel< T >Chessboard filter kernel or square filter kernel
lti::chiSquareFunctorChiSquareFunctor calculates the chiSquareValue indicating the likelihood, that the considerd elements are drawn from a gaussian normal distribution
lti::choleskyDecomposition< T >This functor calculates the Cholesky decomposition of a symmetric, positive-definite matrix A
lti::chromaticityHistogramCreate a chromaticity histrogram feature vector
lti::chrominanceMapEstimatorThis class computes a map between the chrominances and the most likely object based on chrominance histograms and the Bayes Theorem
lti::chrominanceMapMaskingThis class performs color segmentation in the chrominance plane using a chrominance map which may be drawn manually or computed by the chrominance map estimator class
lti::chrominanceModelEstimatorThis class stores a 2d histogram containing all chrominances which have been seen on a specific object
lti::cityBlockKernel< T >CityBlock filter kernel
lti::classicEdgeDetectorThis class implements simple standard edgedectors like Sobel
lti::classificationStatisticsThis class allows the generation of classification statistics
lti::classifierAbstract parent class for all classifiers
lti::classifier2DVisualizerThis functor creates beautiful pictures
lti::classNameProvides methods for getting the class names of lti::objects
lti::sparseHistogram::clessComparator for C-strings (null-terminated char array)
lti::clusteringBase class for all clustering algorithms
lti::clusteringValidityParent class for all clustering validity measures
lti::cmykColorA little class for defining points in the CMYK color space
lti::coilBackgroundSegmentationThe coilBackgroundSegmentation functor tries to detect which pixels belong to the background and which not
lti::colorACASegmentationColor Adaptive Clustering Algorithm
lti::colorContrastGradientThe contrast gradient is used in color or multi-spectral image as a replacement of the gray-value gradient in gray images
lti::colorDialogAllows to choose a color in the HSI or RGB color space
lti::colorEdgesGSGevers and Stokman color edges
lti::colorModelEstimatorThis functor is used to create three-dimensional histograms for the colors of images
lti::colorModelSelectorThis functor selects one color model from a set, which elements were given by addColorModel
lti::colorNormalizationBaseParent class for color normalization methods usually used to eliminate the effects of illumination changes
lti::colorQuantizationAbstract parent class for all color quantization algorithms All color quantization functors must overload the apply-member defined here
lti::combinationThis class is used to combine several results of different classifier::output objects
lti::combinedCodecThis is the base class for data encoding and decoding
lti::competitiveAgglomerationThis class implements the centroid clustering algorithm presented in "Clustering by Competitive Agglomeration" from Frigui and Krishnapuram, Pattern Recognition, Vol
lti::complex< T >Class to represent and manipulate complex numbers
lti::comprehensiveColourNormalizationThis class implements the algorithm described in the paper "Comprehensive Colour Image Normalization" by Finlayson, Schiele and Crowley
lti::computePaletteThis class is used to compute a palette given a color image and an index mask
lti::viewer::configChannelFixedConfiguration Dialog for viewer of images of fixed point scalar values, like channel8 or matrix<int>
lti::viewer::configChannelFloatConfiguration Dialog for viewer of images of floating point scalar values, like channel or matrix<double>
lti::viewer::configDialogParent class for all types of configuration dialogs for the normal viewer
lti::histogramViewer::configDialogGTK Widget for the configuration dialog of the histogram viewer
lti::viewerBase3D::configDialogGTK Widget for the configuration dialog of the histogram viewer
lti::configFileHandlerWrite and read config files, similar to windows ini files
lti::configGTKDialogWidget for the statistics dialog
lti::viewer::configImageConfiguration Dialog for viewer of images of rgbPixel elements
lti::viewer::configVectorConfiguration Dialog for viewer of vectors
lti::adjacencyGraph< N, W, D, F, E >::const_edge_iteratorThe graph const_iterator iterates on all nodes in a read-only fashion
lti::smallObjectList< T >::const_iteratorConst_iterator class (allows read-only operations) The use of the iterator classes is similar to the iterators of the STL (Standard Template Library)
lti::sparseHistogram::const_iteratorSimilar to the const_iterators of the sparse matrix, these iterators allow read-only access the non-sparse cells of the histogram
lti::tree< T >::const_iteratorConst iterator type (allows read-only operations)
lti::adjacencyGraph< N, W, D, F, E >::const_iteratorThe graph const_iterator iterates on all nodes in a read-only fashion
lti::genericMatrix< T >::const_iteratorConst iterator type (allows read-only operations)
lti::genericVector< T >::const_iteratorConst iterator type (allows read-only operations)
lti::constants< T >This class is a container of some mathematical and physical constants
lti::genericVector< T >::constReferenceExceptionConstReferenceException class
lti::continuousRandomDistributionBase random number class
lti::convexHullComputes the convex hull of a set of points
lti::convHelper1D< T, A >Pre-convolution algorithm for a vector * kernel1D The type T is the type of the elements of the vector and kernel1D The class A determines how the values should be accumulated
lti::convHelper2D< T, A >Pre-convolution algorithm for a matrix * kernel2D The type T is the type of the elements of the vector an kernel1D The class A determines how the values should be accumulated
lti::convolutionConvolution functor
lti::coordinateTransformationThis class transforms the coordinates of a 3D point between two coordinate systems
lti::cornerDetectorParent class for all corner detectors
lti::cornerDetectorFactoryThis class defines a factory for corner detector functors
lti::correlationCorrelation functor
lti::cosinus2Similarity< T >Quadratic Cosinus Similarity
lti::costFunctionBase class for all cost functions
lti::crispDecisionTree::crispDecisionFunctionBase class for decision functions of crispNode
lti::crispDecisionTreeBase class for all crisp decision trees
lti::crispDecisionTree::crispNodeA crisp decision tree node
lti::crossCorrelationCoefficientThis class computes the normalized cross correlation coefficient between two matrices or vectors
lti::crossValidatorThis class does a cross validation on the given dataset and returns the average recognition rates
lti::csPresegmentationThe csPresegmentation functor (states for color space presegmentation) tries to detect which pixels belong to the background and which not
lti::cubicSpline< T >This functor implements a cubic spline interpolation for tabulated functions
lti::curvatureFeatureThe curvature feature is similar to the lti::orientationFeature, but instead of creating a histogram of the pixel orientations, a histogram of the curvature of a pixel will be done, considering also the "relevance" channel when constructing it
lti::curvatureScaleSpaceCurvature Scale Space Representation (CSS)
lti::cwagmSegmentationCWAGM Segmentation
lti::cyclicTridiagonalEquationSystem< T >Solves a special kind of linear equation system, where only the main diagonal and the first lower and upper sub-diagonals and the two "other corners" (top right and bottom left) of the matrix are non-zero
lti::dataCodecThis is the base class for data encoding and decoding
lti::dataTransformerThis is the low-level base class for data transformers
lti::daubechies16Kernel16 tap Daubechies filter kernel
lti::daviesBouldinIndexCalculates the Davies Bouldin Index of the given clustering
lti::DBScan< T >A class providing the DBScan for clustering
lti::decimationDecimation
lti::decisionTreeThis is the base class for all decision trees in the LTI-Lib
lti::decompositionSolution< T >Abstract base class for all lti linear equation system solution functors using matrix decomposition to solve Ax=b
lti::endianness::defaultEndianThis class encapsulates the endianness of the processor used
lti::delaunayTriangulation< T >This class performs a delaunay triangulation on a given std::vector<tpoint<T> >
lti::dilationDilation functor
lti::directedPerceptionPTUThis class performs handling of the pan-tilt unit PTU-D46-17 from the manufactor DirectedPerception
lti::discreteRandomDistributionBase random number class
lti::DistanceFromPixelThis class derives the 3D position of an object from a 2D image point
lti::distanceFunctor< T >This class is the base class for all functors which compute distances between two vectors or matrices as well as norms of vectors and matrices
lti::stdLayer::distancePropFunctorDistance propagation functor
lti::distanceTransformThis simple morphological operator assumes that the input data is a binary image, i.e
lti::distanceType< T >This class defines the appropriate return types when calculating the distance between to values of type T
lti::stdLayer::dotPropFunctorDot-Product propagation functor
lti::earthMoversDistance< W, C, D >::double_nodeType for a double linked list
lti::downsamplingThis functor is used to downsample images
lti::draw< T >Object for drawing a number of geometric figures and lists thereof, simple texts and a few other types with graphic representation in a lti::matrix
lti::draw2DDistribution< T >This class draws a 2-D distribution into an image or a channel
lti::draw3D< T >Tool for drawing 3D points and lines in a lti::matrix
lti::draw3DDistributionDraws a three dimensional distribution
lti::drawBase< T >Abstract parent class for draw and epsDraw
lti::drawFlowFieldDraws the visualization of a two dimensional flowfield
lti::decisionTree::dtNodeSimple Node for decision trees
lti::dummyFunctorA dummy functor that is evaluated with the paretoFront
lti::dunnIndexComputes the Dunn Index and its generalisations described in Bezdek, J.C.,Pal,N.R., 1998
lti::dynamicMatrix< T >This template class allows the use of matrices which change its dimensions without losing any data
lti::earthMoversDistance< W, C, D >The Earth Mover's Distance (EMD) is a robust distance measure between two distributions
lti::adjacencyGraph< N, W, D, F, E >::edge_iteratorThe edge iterator iterates on all outgoing edges of a node
lti::edgeDetectorParent abstract class for all edge detectors
lti::edgeDetectorFactoryThis class defines a factory for edge detector functors
lti::edgeSaliencyA class for edge based strcutural saliency calculations
lti::eigenSystem< T >EigenSystem functor
lti::snake::elementStructure for a snake element
lti::kdTree< T, D, U >::elementAt the leave nodes, a list of elements of this type will contain the points and their corresponding data
lti::endiannessEndianness This class is used to read data from a file with a known endianness
lti::entropyFunctor< T >Functor which computes entropy for vectors and matrices
lti::adjacencyGraph< N, W, D, F, E >::entry_typeEntry type used in the sparse matrix representing the affinity matrix
lti::epsDraw< T >Object for drawing lines and points and geometric objects to an (E)PS file
lti::equallySpacedSamplesInterpolatorThis abstract class parents all interpolation functors, whose samples have equal distances to each other (per dimension)
lti::erosionErosion functor
lti::euclideanKernel< T >Euclidean filter kernel
lti::euclideanSimilarity< T >Euclidean Similarity Measure
lti::exceptionBase class for all lti-library exceptions
lti::expandVectorThis class is used to map a function f(x) represented by a vector into another scale f(g(x)), where g(x) can be given
lti::exponentialDistributionExponentially distributed random number class
lti::sonyEviD100P::externPollIf an user wants to send inquiries to the device and process the answers explicitly, he may obtain a reference to this class
lti::externViewerThis object shows an image using an external application like kview, xv, mspaint, etc
lti::faceThresholdThe ltiFaceThreshold-class calculates for a given skin probability mask of an image an extraction-threshold that allows to 'cut-out' the face (blob) of the shown person
lti::fastCircleExtractionThis functor implements a fast circle extraction using the line segments found in digital images
lti::fastEigenSystem< T >A fast LAPACK-based method for computation of (some) eigenvector and eigenvalues
lti::fastEllipseExtractionThis functor implements a fast ellipse extraction using the line segments found in digital images
lti::fastGeneralizedEigenSystem< T >Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x, A*Bx=(lambda)*x, or B*A*x=(lambda)*x
lti::fastICA< T >This class implements a fast fixed point algorithm for the Independent Component Analysis (ICA)
lti::fastLineExtractionThis functor implements a fast line extraction using the line segments found in digital images
lti::geometricTransform::fastMatrixStructure to avoid the use of the access operator of matrices
lti::fastRelabelingThis functor takes a mask (labeled or not), where it is assumed that a region must be connected or not and reassignes labels to them in a way that each connected region gets its own label
lti::fastSVD< T >A fast LAPACK-based method for computation of the singular value decomposition SVD
lti::featureExtractorThe feature extractors are functors which extract information from the given images or channels, and leave this information in the form of vectors of doubles
lti::featureSaliencyAxFeature saliency map for AXIOM
lti::featureSaliencyIKFeature Saliency for color images
lti::featureSelectorAbstract base class for all feature selectors
lti::filledUpsamplingFilled Upsampling
lti::fillPatternFill pattern class
lti::filterBase class for all filters
lti::fireWireDCAMGrab imags from FireWire Cameras
lti::flipImageFlips an image horizontally or vertically
lti::fMatrixEstimatorA class for estimating the fundamental matrix with a least squares approach
lti::fMatrixEstimatorBaseA base class for estimating the fundamental matrix with a least squares approach
lti::fireWireDCAM::format7InfoStructure to hold format 7 information
lti::fireWireDCAM::format7ModeInfoStructure to hold format 7 mode information
lti::forwardSubstitution< T >Forward substitution
lti::fourierDescriptorThis class generates fourier descriptors
lti::frameGrabberFrame grabber class
lti::frameGrabber::frameGrabberExceptionClass for frame grabber exceptions
lti::frankotChellapaThe Francot-Chellapa argorithm extracts a depth image from an intensity image
lti::functionGeneratorFunctionGenerator parses input strings representing mathematical functions of the type $f(x)$ and $f(x,y)$
lti::functorBase class for all lti functors
lti::fundamentalMatrixSolverLMSThis Algorithm determines the fundamental matrix from point correnspondences in two images
lti::fuzzyCMeansThis class implements the fuzzy C Means clustering algorithm
lti::gaborKernel< T >Two-dimensional gabor filter kernel
lti::gaborKernelSep< T >Two-dimensional separable gabor filter kernel
lti::gaborPyramid< T >GaborPyramid class
lti::gammaDistributionGamma distributed random number class
lti::stdLayer::gaussActFunctorGaussian activation function
lti::blobEM::gaussEllipseAn internal class of lti::blobEM for handling 2D gaussian ellipses
lti::gaussian< T >This function evaluates a multivariate gaussian with the form:

\[ g(\mathbf{x}) = \frac{1}{(2\pi)^{n/2} |\boldsymbol{\Sigma}|^{1/2}} \cdot \exp\left(-\frac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^T \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right)\]

lti::gaussianDistributionNormal distributed random number class
lti::gaussianMixtureModel< T >Functor which estimates a gaussian mixture model of a given data set
lti::gaussianPyramid< T >GaussianPyramid class
lti::gaussKernel1D< T >One-dimensional filter kernel
lti::gaussKernel2D< T >Two-dimensional Gaussian filter kernel
lti::generalEigenVectors< T >Generic eigenvalues and eigenvectors computations
lti::generalizedEigenSystem< T >Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite eigenproblem, of the form A*x=(lambda)*B*x
lti::genericInterpolator< T >This functor use a generic interpolation concept based on look-up-tables for the interpolation kernels
lti::genericMatrix< T >GenericMatrix container class
lti::genericVector< T >Vector container class
lti::geometricFeatureGroup0Description of the simpliest geometric features given by the rectangle surrounding the object, the object's area and the center of gravity
lti::geometricFeaturesComputes features, which describe some geometric properties of a 2D shape
lti::geometricFeaturesFromMaskThis functor takes a mask (labeled or not), where it is assumed that a region must be connected or not and reassigned labels to them in a way that each connected region gets its own label
lti::geometricTransformThis functor implements an generic geometric transform based on a homogeneous matrix, which is able to represent rotations, translations scalings and all other possibilites of homographies
lti::getStreamFdThis functor can be used to access the file descriptor that is used within a stream object
lti::gHoughTransformThe Generalized-Hough-Transform
lti::globalFeatureExtractorThe feature extractors are functors which extract information from the given images or channels, and leave this information in the form of vectors of doubles
lti::gradientASMThis class implements an alignment strategy for activeShapeModel (ASM)
lti::gradientFunctorThe gradient is a simple wrapper for the convolution functor with some convenience parameterization to choose between different common gradient kernels
lti::gradientKernelX< T >Two-dimensional separable filter kernels for the gradient approximation
lti::gradientKernelY< T >Two-dimensional separable filter kernels for the gradient approximation
lti::graphicsPatternGraphicsPattern template class
lti::grayWorldNormalizationPerforms a color normalization on an lti::image using a gray world approach, in order to eliminate effects of illumination colour
lti::gtkServerServer to administrate gtk GUI
lti::gtkServer::guiThreadAn instance of this class will be the GUI server object, called gtkServer
lti::guyMedioniSaliencyThe Guy-Medioni saliency is a procedure for perceptual grouping of low level features like points and edges
lti::haarKernelHaar filter kernel
lti::harrisCornersHarris Corner Detector
lti::harrisKernelX< T >Harris Kernel X
lti::harrisKernelXX< T >Harris Kernel XX
lti::harrisKernelXY< T >Harris Kernel XY
lti::harrisKernelY< T >Harris Kernel Y
lti::harrisKernelYY< T >Harris Kernel YY
lti::kMColorQuantization::kMeanColor::hashEntryEntry of the hash table contains the number of pixels in the image that have the color corresponding to this entry (counter) and the index of this color in the cetroid-vector;
lti::ioBMP::headerBITMAPFILEHEADER:
lti::lncFeatureFile::headerHeader of a lnc feature file
lti::ioLTI::headerLTI-Format file header
lti::hessianFunctorThe hessianFunctor calculates three channels from an input channel L:
lti::hessianKernelXXTwo-dimensional kernels to compute the Hessian coefficients
lti::hessianKernelXYTwo-dimensional kernels to compute the Hessian coefficients
lti::hessianKernelYYTwo-dimensional kernels to compute the Hessian coefficients
lti::hiddenMarkovModelHidden Markov Model (HMM) class
lti::histogram1DOne dimensional histogram of type double
lti::histogram2DTwo dimensional histogram of type double
lti::histogramEqualizationHistogramEqualization equalizes the values of the given channel, channel8, vector<ubyte> or fvector within the given input range and maps these equalized values to the given output range
lti::histograming1DThis class extracts a 1D histogram from a channel or channel8
lti::histogramRGBLThis simple feature consists on four independently calculated histograms, one for each color component R, G and B and the luminance L, defined as L = (min(R,G,B) + max(R,G,B))/2
lti::histogramViewerThis class display the histograms of images or channels
lti::draw3D< T >::hmatrixHomogene matrix
lti::hMatrix< T, P >Homogeneous matrix for projective space transformations
lti::hMatrix2D< T >Homogeneous matrix to represent linear transformations in a two-dimensional projective space
lti::hMatrix3D< T >Homogeneous matrix in 3D projective space
lti::hmmClassifierThis class defines training and classification methods for Hidden Markov Models (HMM) using observation sequences
lti::hmmOnlineClassifierThis class allows online classification of word chains
lti::hmmTrainerHidden Markov Model (HMM) trainer
lti::hmmTrellisDiagramDraws the trellis diagram for visualizing the viterbi path selection given by lti::hmmViterbiPathSearch for a lti::hiddenMarkovModel!
lti::hmmViterbiPathSearchThis class finds and evaluates the best path through a Hidden Markov Model (HMM) for a given observation sequence $\mathbf{O}$
lti::homography8DofEstimatorThis class computes the parameters of the perspective transformation between two images using a non-homogenous approach and least squares
lti::homography9DofEstimatorThis class computes the parameters of the perspective transformation between two images using an homogenous approach and least squares
lti::homographyEstimatorBaseA parent class for estimating a transform that can be converted to a homography
lti::homographyEstimatorFactoryThis class defines a factory for homography estimator functors
lti::hPoint2D< T >Homogeneous point in two dimensions Note that an homogeneous two-dimensional point has three elements: x,y and h
lti::hPoint3D< T >Homogeneous point in three dimensions
lti::hsvHistogramViewerA simple HSV histogram viewer
lti::huMomentsExtracts the 7 moment invariants as described in "Visual Pattern Recognition by Moment Invariants" by Ming-Kuei Hu (IRE Transactions on Information Theory, 1962)
lti::identityCodecThis is a dummy codec that does absolutely nothing
lti::imageThe one and only RGB-image format
lti::linearAlgebraFunctor::incompatibleDimensionsExceptionIncompatible dimensions exception
lti::paretoFront::individualStructure characterizing an individual
lti::ioBMP::infoHeaderBITMAPINFOHEADER
lti::stdLayer::initFunctorThis class and all it's derived classes should initialize the network layer
lti::rbf::initFunctor1Initialization functor for rbf
lti::rbf::initFunctor2Initialization functor for rbf networks
lti::interpolatorThis abstract class parents all interpolation functors
lti::functor::invalidMethodExceptionException thrown when a method of a functor is not implemented for a specific parameter set
lti::classifier::invalidMethodExceptionException thrown when a method of a functor is not implemented for a specific parameter set
lti::classifier::invalidOutputExceptionException thrown when the output objects has not been set yet
lti::viewerBase::invalidParametersExceptionException thrown when the parameters are not set
lti::functor::invalidParametersExceptionException thrown when the parameters are not set
lti::classifier::invalidParametersExceptionException thrown when the parameters are not set
lti::ioBMPBase class to functors which load and save images in BMP format
lti::ioFunctorBase class to all io functors
lti::ioHandlerInput/output handlers
lti::ioImageBase class to functors which load and save images in all formats
lti::ioJPEGBase class to functors which load and save images in JPEG format
lti::ioLTIBase class to functors which load and save images in LTI format
lti::ioObjectBasic input/output class for data objects
lti::ioPNGBase class to functors which load and save images in PNG format
lti::ioPointsContour classes: IO-Points
lti::isotropicNormalizationA class for isotropic normalizations of point sets
lti::iteratingFunctor< T >Base class for all iterating functors
lti::smallObjectList< T >::iteratorIterator class (allows read and write operations) The use of the iterator classes is similar to the iterators of the STL (Standard Template Library)
lti::sparseHistogram::iteratorSimilar to the iterators of the sparse matrix, these iterators allow to access the non-sparse cells of the histogram
lti::tree< T >::iteratorIterator type (allows read and write operations)
lti::adjacencyGraph< N, W, D, F, E >::iteratorThe graph iterator iterates on all nodes
lti::genericMatrix< T >::iteratorIterator type (allows read and write operations)
lti::genericVector< T >::iteratorIterator type (allows read and write operations)
lti::jacobi< T >Jacobi functor
lti::kalmanFilterA discrete linear Kalman filter implementation
lti::kalmanTrackerA tracker implementation making use of the class kalmanFilter
lti::kdTree< T, D, U >A class for k-d tree
lti::kernel1D< T >One-dimensional filter kernel
lti::kernel2D< T >Two-dimensional filter kernel
lti::kernelFunctor< T >This class defines a kernel functor
lti::kernelPCAFunctor for computing a kernel principal component analysis
lti::kirschKernelX< T >Kirsch Kernel X
lti::kirschKernelXX< T >Kirsch Kernel XX
lti::kirschKernelXY< T >Kirsch Kernel XY
lti::kirschKernelY< T >Kirsch Kernel Y
lti::kirschKernelYY< T >Kirsch Kernel YY
lti::kMColorQuantizationK-Means based color quantization
lti::kMeansClusteringThis class implements two versions of k-means-clustering: batch and sequential
lti::kMeansSegmentationA segmentation algorithm which is based on a color-quantization algorithm followed by a smoothing filter
lti::kNearestNeighFilterA smoothness filter for label images (channel8,matrix<int>) which uses the idea of the k-Nearest Neighbour concept
lti::kNNClassifierImplements a k nearest neighbors search based classifier
lti::kullbackContrastCalculate the Kullback-Constrast for a channel, as described in: Jagersand, Martin
lti::l1Distance< T >This member accumulates in the given accumulator, the given element
lti::l1Distantor< T, D >Policy class used by several classifiers/trees to measure the distance between two points of type T
lti::chromaticityHistogram::l2accumulator< T >Accumulator class of the squares of the values
lti::l2Distance< T >This member accumulates in the given accumulator, the given element
lti::l2Distantor< T, D >This member accumulates in the given accumulator, the given element
lti::l2SquareDistantor< T, D >Policy class used by several classifiers/trees to measure the square of the euclidian distance between two points of type T
lti::labelAdjacencyMapVisualize a label mask in a color image
lti::lapackInterfaceInterface object for LAPACK functions
lti::laplacianKernelTwo-dimensional kernels to compute the Laplacian
lti::laplacianPyramid< T >LaplacianPyramid class
lti::lvq::layerLvq layer
lti::rbf::layer1Layer 1 for rbf networks
lti::rbf::layer2Layer 2 for rbf networks
lti::graphicsPattern::lessA comparator used for sorting patterns
lti::leutronFrameGrabberInterface to all Leutron framegrabbers in the system
lti::stdLayer::linearActFunctorLinear activation function
lti::MLP::linearActFunctorLinear activation function
lti::linearAlgebraFunctorBase class for all lti linear algebra functors
lti::linearDiscriminantAnalysis< T >Functor for computing a linear discriminant analysis (LDA)
lti::linearEquationSystemSolutionMethod< T >Abstract base class for all lti linear equation system solution functors to solve Ax=b
lti::linearKernelThis class defines a linear kernel functor
lti::linearMapperFunctor< Tin, Tout >This functor maps a vector space of type Tin into another vector space of type Tout
lti::linearMixer< T >Implements a mixing operator for vectors and matrices
lti::linearRegression< T >The linear regression algorithm estimates a linear relation between two vector spaces
lti::linearRegressionTrackingWith this tracking algorithm it is possible to track the movement of an object together with scaling and rotation in the image plane
lti::linearSatMapperFunctor< Tin, Tout >This functor maps a vector space of type Tin into another vector space of type Tout
lti::linePatternLine pattern class
lti::lispStreamHandlerOffer an interface for the functor parameters and other classes to read() and write() them in a LISP-like format
lti::lkmColorQuantizationColor quantization functor based on the local k-Means algorithm of O
lti::lkTrackerThis functor implements a hierachical Lucas Kanade optical flow
lti::lncFeatureFileParent class for the functors which deal with the ASCII file format to store feature vectors
lti::loadBMPFunctor to read a bitmap (BMP) file
lti::loadImageFunctor to read an image file
lti::loadImageListThis functor loads images given either in a std::list of strings, a special file or a whole directory: Each apply call loads the next image from the list
lti::loadJPEGFunctor to read a JPEG file It is NOT thread save, this means, the SAME instance can not be used from different threads or processes at the same time
lti::loadLncClass to load lnc-files (ascii format to store feature vectors)
lti::loadLTIFunctor to read a bitmap (LTI) file
lti::loadPNGFunctor to read a Portable Network Graphic (PNG) file
lti::loadVectorImageListThis functor loads a list of images and transforms each into a vector or all into a matrix where each row contains a vector image
lti::localColorFeatureThis functor calculates for each location in a given list color-features
lti::localFeatureExtractorThe local feature extractors are functors which extract information from the given images or channels at the given locations
lti::localMaxima< T >This simple functor tries to find the local maxima at a given window and suppresses all other values, setting them the "nonMaxValue" given in the parameters (usually 0)
lti::localMomentsThis local feature extractor can be used to estimate the standardized moments (Mean, Variance, Skew and Kurtosis) of a certain circular area around the given location
lti::locationSmall region in an image or channel
lti::locationSearchEvaluationPareto evaluation of the lti::pyramidLocationSearch functor
lti::locationSelectorThis functor adjust the given list of locations by a given mask
lti::logarithm< T >Logarithm functor class
lti::loweGradientFeatureLocal feature based on the gradient distribution at the level of the location
lti::luDecomposition< T >LU decomposition functor
lti::luSolution< T >LU solution functor
lti::meanShiftSegmentation::luvPixelLike rgbPixel for RGB-ColorSpace, is luvPixel for LUV-ColorSpace
lti::lvqLVQ-Net
lti::lvq::lvq1TrainFunctorLVQ1
lti::lvq::lvq3TrainFunctorLVQ3
lti::lvq::lvq4TrainFunctorLVQ4
lti::mahalanobisDistanceThis class computes the mahalanobis distance
lti::mahalanobisDistOfSubsetThis class implements a cost function for evaluating a subset of features based on the mahalanobis distance
lti::mainGTKWindowThis class encapsulates all signals and calls of the GTK library
lti::histogramViewer::mainWindowGTK Widget for the main class of the histogram viewer
lti::scene3DViewer::mainWindowGTK Widget for the main class of the histogram viewer
lti::viewer::mainWindowAbstract class for all main windows for the different data types
lti::viewerBase3D::mainWindowWidget for the main class of the histogram viewer
lti::viewer::mainWndChannelFixedMain Window for channels of fixed point values
lti::viewer::mainWndChannelFloatMain Window for channels of floating point values
lti::viewer::mainWndImageMain Window for color images
lti::viewer::mainWndVectorMain Window for vectors
lti::manualCrispDecisionTreeThis class serves the manual construction of a crisp decision tree with crispNodes that have univariate decision functions
lti::mapperFunctor< Tin, Tout >This class maps a vector in a n-dimensional space into another vector in a m-dimensional space
lti::maskAlgebraicSum< T >Alias with standard LTI-Lib interface for mask-algebraicSum member of the maskFunctor
lti::maskAnd< T >Alias with standard LTI-Lib interface for maskAnd member of the maskFunctor
lti::maskFunctor< T >The mask functor is a colection of boolean operations used in the processing of mask images or matrices
lti::maskImageThis functor is used to mask color images with labeled or unlabeled masks
lti::maskInvert< T >Alias with standard LTI-Lib interface for invert member of the maskFunctor
lti::maskMultiply< T >Alias with standard LTI-Lib interface for mask-multiply member of the maskFunctor
lti::maskNot< T >Alias with standard LTI-Lib interface for maskNot member of the maskFunctor
lti::maskOr< T >Alias with standard LTI-interface for maskOr member of the maskFunctor
lti::mathFunctionAbstract class, used as parent for all mathematical parametrical functions, like multi-variate gaussians
lti::mathObjectBase object for the math-classes
lti::matrix< T >Mathematical matrix container class
lti::matrixInversion< T >Matrix inversion functor
lti::lapackInterface::matrixNotConnectedException class denoting an illegal matrix format (non-connected) All matrices used by LAPACK routines must be connected
lti::lvq::maxDistInitFunctorMaximum distance initialization
lti::maximumFilter< T >This is an efficient implementation of the non-linear maximum filter
lti::meansFunctor< T >Functor which computes several kinds of means for vectors and matrices
lti::meanShiftSegmentationThis is the implementation of the mean shift segmentation algorithm
lti::meanshiftTrackerThis is the implementation of the MEANSHIFT Tracking algorithm as described in: Comaniciu, Ramesh and Meer, "Real-Time Tracking of Non-Rigid Objects using the Mean Shift", IEEE Workshop on Applic.Comp.Vis.,2000
lti::medianCutThis class does color quantization with median-cut-algorithm (Heckbert, MIT 1980)
lti::medianFilterThis class implements the median filter
lti::mergeCIELuvToImageMerge CIE Luv channel into an color image
lti::mergeHLSToImageMerge HLS channels (Hue, Luminance, Saturation)
lti::mergeHSIToImageMerge HSI (Hue Saturation Intensity) channels
lti::mergeHSVToImageMerge HSV channels (Hue, Saturation, Value)
lti::mergeImageBase class for all merge image functor-classes
lti::mergeOCPToImageMerge linear opponent color channels OCP
lti::mergeRGBToImageMerge RGB channels
lti::mergergIToImageMerge chromaticity channels rgI
lti::mergexyYToImageMerge chromaticity xyY channels
lti::mergeXYZToImageMerge XYZ channels
lti::mergeYCbCrToImageCreates RGB values from given YCbCr values by merging float or ubyte values to an rgbPixel, merging channels(floats) or channel8s(ubytes) to an Image
lti::mergeYIQToImageMerge YIQ channels (Luminance, Inphase, Quadrature)
lti::mergeYPbPrToImageCreates RGB values from given YPbPr values by merging float or ubyte values to an rgbPixel, merging channels(floats) or channel8s(ubytes) to an Image
lti::mergeYUVToImageCompute RGB values from given YUV values by merging float or ubyte values to an rgbPixel, merging channels(floats) or channel8s(ubytes) to an Image
lti::microEnablePulnixSilicon Software channel link frame grabber (Linux version!)
lti::minimizeBasis< T >MinimizeBasis functor
lti::minimumSpanningTree< K, V, Distantor >This class computes minimum spanning trees
lti::minimumSpanningTreeOfKeytype< K, V, Distantor >Computes a minimum spanning tree
lti::minimumSpanningTreeOfKeyValuetype< K, V, Distantor >Computes a minimum spanning tree of a given data set
lti::MLPMulti-layer perceptrons
lti::modHubertStatCalculates the modified Hubert statistic of the given clustering
lti::modifierBase class for all filters and other functors, which transform an image or channel in another image of the same type
lti::monteCarloEstimatorA parent class for estimating a transform from point sets while detecting and discarding outliers
lti::morphologyBase class for all morphological operators
lti::MSTClustering< U >This class implements a minimum spanning tree clustering
lti::multiclassNormalizedCutsMulticlass normalized cuts
lti::multiGeometricFeaturesFromMaskThis functor takes a mask (labeled or not), where it is assumed that a region must be connected or not and reassigns labels to them in a way that each connected region gets its own label
lti::multiplyScalar< T >Multiply by Scalar functor class
lti::crispDecisionTree::multivariateCrispDecisionFunctionThis class implements a multivariate decision
lti::multivariateGaussianThis class generates either one point from a given covarianceMatrix and centre or it generates a given number of points according to these parameters
lti::mutexLti mutex class
lti::fireWireDCAM::nameDBCamera database
lti::colorModelSelector::namedModelInternal data type to facilitate the administration of named color models
lti::nearestNeighborInterpolator< T >This functor use nearestNeighbor interpolation to approximate values between the pixels or elements of vectors and matrices
lti::tree< T >::nodeThe elements of the tree are instances of the "node" class
lti::weightedGraph< P, D, W >::nodeElements of the graph are instances of this class
lti::kdTree< T, D, U >::nodeClass of nodes of the kd-tree
lti::tree< T >::nodeManagerThe nodeManager takes care of the memory administration
lti::noise< T >Noise class
lti::nonMaximaSuppressionThe non-maxima suppression is usually the last stage of edge detectors (the most prominent example is the Canny Edge Detector, see lti::cannyEdges), but it can also be employed in other similar tasks, like detection of saliency edges from "structural" saliency maps (see for example lti::guyMedioniSaliency)
lti::normModHubertStatCalculates the normalized version of the modified Hubert statistic The index is between -1 and 1
lti::objectBase class for all lti objects
lti::objectFactory< T >This class defines a factory for objects
lti::objectsFromMaskThis class works on channel8/imatrix to extract connected components and describes them as the topological order of "objects" and "holes"
lti::objectsFromMask::objectStructThis node-structure for storing information about all objects and holes in the tree
lti::octagonalKernel< T >Octagonal filter kernel
lti::ogd1Kernel< T >First order Oriented Gaussian Derivative
lti::ogd2Kernel< T >Second order Oriented Gaussian Derivative
lti::ogdFilterOriented gaussian derivatives steerable filters
lti::lvq::olvq1TrainFunctorOLVQ1
lti::lvq::olvq3TrainFunctorOLVQ3
lti::opponentColorThis functor generates an "opponent color" channel from the given two channels, one representing the center, the other representing the surround
lti::endianness::oppositeEndianIf file endianness is the opposite as the system endianness
lti::opticalFlowHSComputes the optical flow between two consecutive images according to Horn-Schunks gradient based method
lti::opticalFlowLKThis class computes the optical flow between two consecutive images according to the gradient based method of Lucas+Kanade
lti::optimalThresholdingThreshold segmentation of a single channel with the optimal threshold value
lti::orientationFeatureThe orientation feature takes two channels: a "relevance" channel and an "orientation" channel, and with them it creates an orientation histogram with the given number of cells
lti::orientationMapGenerate an orientation map of a given channel
lti::orientedHLTransformThis functor is used to make a fast Hough Line Transform and creates a channel32 transformation accumulator
lti::classifier::outputTemplateThe outputTemplate stores the relation between the different positions (sometimes called internal ids) of a classification result and the ids
lti::classifier::outputVectorAn output vector is the result of classifying data with any classifier
lti::overlappingSets2DConsidering 2d sets, which may overlap, one might ask in which sets a particular 2d point is contained
lti::viewerBase3D::configDialog::pageWidgetStructure used in the elements of the list of all pages of the configuration dialog
lti::ioBMP::paletteColor Palette
lti::panTiltUnitParent class for all pan tilt units
lti::similarityFunctor< T >::parametersParameters for the class similarityFunctor
lti::configFileHandler::parametersParameters for the class configFileHandler
lti::functor::parametersBase class for all lti parameter objects
lti::featureSaliencyIK::parametersParameters for the class featureSaliencyIK
lti::hsvHistogramViewer::parametersParameters for the class hsvHistogramViewer
lti::sort< T >::parametersThe parameters for the class sort
lti::medianFilter::parametersParameters for the class medianFilter
lti::distanceFunctor< T >::parametersParameters for the class distanceFunctor
lti::globalFeatureExtractor::parametersParameters for the class globalFeatureExtractor
lti::guyMedioniSaliency::parametersParameters for the class guyMedioniSaliency
lti::transform::parametersTransform Functor parameters class
lti::classifier2DVisualizer::parametersParameters for the class classifier2DVisualizer
lti::backgroundModel::parametersParameters for the class backgroundModel
lti::convexHull::parametersParameters for the class convexHull
lti::singularValueDecomp< T >::parametersParameters for the class
lti::kMeansClustering::parametersParameters for kMeansClustering
lti::MLP::parametersParameters for the class MLP
lti::harrisCorners::parametersParameters for the class harrisCorners
lti::MSTClustering< U >::parametersParameters for the class MSTClustering
lti::convolution::parametersParameters of the lti::convolution functor
lti::variablySpacedSamplesInterpolator::parametersParameters for the class variablySpacedSamplesInterpolator
lti::binomialDistribution::parametersParameters for the class binomialDistribution
lti::unifiedGeneralizedEigenSystem< T >::parametersParameters for the class unifiedGeneralizedEigenSystem
lti::modifier::parametersParameter class for modifier
lti::grayWorldNormalization::parametersThe parameters for the class grayWorldNormalization
lti::flipImage::parametersParameters for the class flipImage
lti::monteCarloEstimator::parametersThe parameters for the class monteCarloEstimator
lti::uniformDistribution::parametersParameters class for the uniform distribution
lti::uciDataWriter::parametersParameters for the class uciDataWriter
lti::clustering::parametersParameters for clustering functors
lti::morphology::parametersParameters for the class morphology
lti::plusLTakeAwayR::parametersParameters for the class plusLTakeAwayR
lti::multiclassNormalizedCuts::parametersParameters for the class multiclassNormalizedCuts
lti::cornerDetector::parametersParameters for the class cornerDetector
lti::getStreamFd::parametersParameters for the class streamAccess
lti::squareConvolution< T, A >::parametersParameters for the class squareConvolution
lti::nonMaximaSuppression::parametersParameters for the class nonMaximaSuppression
lti::polynomialKernel::parametersParameters for the class kernelFunctor
lti::serial::parametersParameters for the class serial
lti::objectsFromMask::parametersParameters for the class objectsFromMask
lti::correlation::parametersParameters of the lti::correlation functor
lti::translationScaleEstimator::parametersThe parameters for the class translationScaleEstimator
lti::externViewer::parametersParameters for the externViewer-object
lti::ogdFilter::parametersParameters for all ogd filters
lti::filledUpsampling::parametersParameters for the class upsampling
lti::opticalFlowHS::parametersParameters for the class opticalFlowHS
lti::scene3DViewer::parametersParameters for the class viewerBase3D
lti::viewer::parametersThe parameters for the class viewer
lti::opticalFlowLK::parametersParameters for the class opticalFlowLK
lti::optimalThresholding::parametersParameters for the class optimalThresholding
lti::crossCorrelationCoefficient::parametersThe parameters for the class crossCorrelationCoefficient
lti::hmmTrainer::parametersParameters for the class hmmTrainer
lti::viewerBase::parametersBase class for all lti parameter objects
lti::fuzzyCMeans::parametersParameters for the class fuzzyCMeans
lti::viewerBase3D::parametersThe parameters for the class viewerBase3D
lti::curvatureFeature::parametersParameters for the class curvatureFeature
lti::overlappingSets2D::parametersThe parameters for the class overlappingSets2D
lti::loadVectorImageList::parametersThe parameters for the class loadVectorImageList
lti::rbf::parametersParameters class for the RBF-Networks
lti::pdmGenerator::parametersParameters for the class pdmGenerator
lti::curvatureScaleSpace::parametersParameters for the class curvatureScaleSpace
lti::linearDiscriminantAnalysis< T >::parametersParameters for the class linearDiscriminantAnalysis
lti::pointSetNormalization::parametersThe parameters for the class pointSetNormalization
lti::cwagmSegmentation::parametersParameters for the class cwagmSegmentation
lti::polarToCartesian< T >::parametersParameters for the class polarToCartesian
lti::meansFunctor< T >::parametersParameters for the class meansFunctor
lti::qmf::parametersParameters for the class qmf
lti::skinASM::parametersParameters for the class skinASM
lti::polygonApproximation::parametersParameters for the class polygonApproximation
lti::segmentationEvaluation::parametersThe parameters for the class segmentationEvaluation
lti::geometricFeaturesFromMask::parametersParameters for the class geometricFeaturesFromMask
lti::probabilityMap::parametersThe parameters for the class probabilityMap
lti::adaptiveKMeans::parametersParameters for the class adaptiveKMeans
lti::fireWireDCAM::parametersThe parameters for the class fireWireDCAM
lti::statisticsFunctor::parametersParameters for the class statisticsFunctor
lti::hmmClassifier::parametersParameters for the class hmmClassifier
lti::pyramidLocationSearch::parametersThe parameters for the class pyramidLocationSearch
lti::snake::parametersParameters for the snakes
lti::frameGrabber::parametersFrameGrabber parameters class
lti::distanceTransform::parametersParameters for the class distanceTransform
lti::scalarValuedInterpolation< T >::parametersParameters for the class scalarValuedInterpolation
lti::serialStatsExtFunctor< T, U >::parametersParameters for the class meansFunctor
lti::recognitionRateOfSubset::parametersParameters for the class recognitionRateOfSubset
lti::genericInterpolator< T >::parametersThe parameters for the class genericInterpolator
lti::qmfEnergy::parametersParameters for the class qmfEnergy
lti::ioFunctor::parametersIoFunctor parameters class
lti::thresholdSegmentation::parametersParameters for the class thresholdSegmentation
lti::fastRelabeling::parametersParameters for the class fastRelabeling
lti::downsampling::parametersParameters for the class downsampling
lti::unifiedSymmetricEigenSystem< T >::parametersParameters for the class unifiedSymmetricEigenSystem
lti::varianceFunctor< T >::parametersParameters for the class varianceFunctor
lti::sammonsMapping::parametersParameters for the class sammonsMapping
lti::quadTreeSegmentation::parametersThe parameters for the class quadTreeSegmentation
lti::combination::parametersParameters for the class combination
lti::ransacEstimator::parametersThe parameters for the class ransacEstimator
lti::realFFT::parametersParameter class of the realFFT class
lti::upsampling::parametersParameters for the class upsampling
lti::unifiedSVD< T >::parametersParameters for the class unifiedSVD
lti::draw2DDistribution< T >::parametersParameters for the class draw2DDistribution
lti::featureSaliencyAx::parametersParameters for the class featureSaliencyAx
lti::histogramViewer::parametersParameters for the class viewerBase3D
lti::draw3D< T >::parametersParameters for draw3D
lti::sffs::parametersParameters for the class sffs
lti::regionGrowing::parametersThe parameters for the class regionGrowing
lti::regionMerge::parametersParameters for the class regionMerge
lti::competitiveAgglomeration::parametersThe parameters for the class competitiveAgglomeration
lti::regionShapeFeatures::parametersParameters for the class regionShapeFeatures
lti::regionsPolygonizer::parametersParameters for the class regionsPolygonizer
lti::susanDenoise::parametersParameters for the class susanDenoise
lti::probabilityMapBase::parametersParameters for the class probabilityMapBase
lti::shClassifier::parametersParameters for the class shClassifier
lti::tridiagonalEquationSystem< T >::parametersTridiagonalEquationSystem parameter class
lti::lncFeatureFile::parametersLncFeatureFile parameters class
lti::edgeDetector::parametersParameters for the class edgeDetector
lti::SOFM2DVisualizer::parametersParameters for the class SOFM2DVisualizer
lti::robustEstimator::parametersThe parameters for the class robustEstimator
lti::rotation::parametersParameters for the class rotation
lti::ioJPEG::parametersParameter class of ioJPEG
lti::drawFlowField::parametersParameters for the class drawFlowField
lti::saliency::parametersparameters class for lti::saliency objects
lti::susanCorners::parametersParameters for the class susanCorners
lti::geometricTransform::parametersThe parameters for the class geometricTransform
lti::leutronFrameGrabber::parametersParameters for the class leutronFrameGrabber
lti::scaling::parametersThe parameters for the class scaling
lti::schieleCrowley6DFeature::parametersParameters for the class schieleCrowley6DFeature
lti::fastICA< T >::parametersThe parameters for the class fastICA
lti::gaussian< T >::parametersParameters for the class gaussian
lti::SOFM2D::parametersParameters for the class SOFM2D
lti::fastCircleExtraction::parametersParameters for the class fastCircleExtraction
lti::erosion::parametersParameters for the class erosion
lti::localColorFeature::parametersThe parameters for the class localColorFeature
lti::earthMoversDistance< W, C, D >::parametersParameters for the class earthMoversDistance
lti::orientedHLTransform::parametersParameters for the class orientedHLTransform
lti::faceThreshold::parametersThe parameters for the class faceThreshold
lti::segmentation::parametersParameters for all segmentation algorithms
lti::localMaxima< T >::parametersParameters for the class localMaxima
lti::selective2DConvolution::parametersParameters for the class selective2DConvolution
lti::shapeFeatureExtractor::parametersParameters for the class shapeFeatureExtractor
lti::shiftInvariance::parametersParameters for the class shiftInvariance
lti::minimumSpanningTree< K, V, Distantor >::parametersParameters for the class minimumSpanningTree
lti::skeleton::parametersParameters for the class skeleton
lti::localFeatureExtractor::parametersThe parameters for the class localFeatureExtractor
lti::serialLDA< T >::parametersParameters for the class serialLDA
lti::noise< T >::parametersScalarParameter class
lti::geometricFeatures::parametersParameters for the class geometricFeatures
lti::principalComponents< T >::parametersParameters for the class principalComponents
lti::multivariateGaussian::parametersParameters for the class multivariateGaussian
lti::fastEllipseExtraction::parametersParameters for the class fastEllipseExtraction
lti::edgeSaliency::parametersParameters for the class edgeSaliency
lti::dummyFunctor::parametersThe parameters for the class dummyFunctor
lti::decimation::parametersParameters for the class decimation
lti::fastLineExtraction::parametersParameters for the class fastLineExtraction
lti::crossValidator::parametersParameters for the class crossValidator
lti::SOFM::parametersParameters for the class SOFM
lti::dilation::parametersParameters for the class dilation
lti::temporalTemplate::parametersParameters for the class temporalTemplate
lti::thresholding::parametersParameters for the class thresholding
lti::transformEstimator::parametersThe parameters for the class transformEstimator
lti::watershedSegmentation::parametersParameters for the class watershedSegmentation
lti::crispDecisionTree::parametersParameters for the class crispDecisionTree
lti::paretoFront::parametersThe parameters for the class paretoFront
lti::filter::parametersParameters class for the filters
lti::forwardSubstitution< T >::parametersParameters for the class forwardSubstitution
lti::binarizationCodec::parametersThe parameters for the class binarizationCodec
lti::usePalette::parametersParameters for the class usePalette
lti::unsupervisedClassifier::parametersParameters for the class unsupervisedClassifier are the same as for classifier, except that the default value of mulipleMode is changed to outputTemplate::Ignore
lti::scaleSpacePyramid< T >::parametersParameters for the generation of scaleSpace pyramids
lti::linearKernel::parametersParameters for the class distanceFunctor
lti::decisionTree::parametersParameters for the class decisionTree
lti::fMatrixEstimatorBase::parametersThe parameters for the class fMatrixEstimatorBase
lti::huMoments::parametersParameters for the class huMoments
lti::sigmoidKernel::parametersParameters for the class distanceFunctor
lti::histogramEqualization::parametersParameters for the class histogramEqualization
lti::minimizeBasis< T >::parametersMinimizeBasis parameter class
lti::functionGenerator::parametersThe parameters for the class functionGenerator
lti::regionGraphFunctor< G >::parametersParameters for the class regionGraphFunctor
lti::frankotChellapa::parametersParameters for the class frankotChellapa
lti::linearRegressionTracking::parametersParameters for the class linearRegressionTracking
lti::DBScan< T >::parametersParameters for the class DBScan
lti::fourierDescriptor::parametersParameters for the class fourierDescriptor
lti::dataCodec::parametersThe parameters for the class dataTransformer
lti::axOGDFeature::parametersThe parameters for the class axOGDFeature
lti::draw3DDistribution::parametersParameters for the class draw3DDistribution
lti::gammaDistribution::parametersParameters for the gamma distribution
lti::colorContrastGradient::parametersParameters for the class gradientFunctor
lti::relativeThresholding::parametersParameters for the class relativeThresholding
lti::axLocalRegions::parametersParameters for the class axLocalRegions
lti::mapperFunctor< Tin, Tout >::parametersParameters for the class mapperFunctor
lti::orientationMap::parametersParameters for the class orientationMap
lti::camera::parametersParameters for the class camera
lti::bayerDemosaicing::parametersThe parameters for the class bayerDemosaicing
lti::featureSelector::parametersParameters for the class featureSelector
lti::svm::parametersParameters for the class svm
lti::csPresegmentation::parametersParameters for the class csPresegmentation
lti::pseudoInverseMP< T >::parametersParameters for the class pseudoInverseMP
lti::lkTracker::parametersParameters for the class lkTracker
lti::matrixInversion< T >::parametersparameters class for lti::matrixInversion functor
lti::probabilityMap2D::parametersParameters for the class probabilityMap2D
lti::multiGeometricFeaturesFromMask::parametersParameters for the class multiGeometricFeaturesFromMask
lti::regularizedPCA< T >::parametersParameters for the class regularizedPCA
lti::saveLnc::parametersLncFeatureFile parameters class
lti::kNNClassifier::parametersParameters for the class kNNClassifier
lti::skinProbabilityMap::parametersParameters for the class skinProbabilityMap
lti::colorModelEstimator::parametersThe parameters for the class colorModelEstimator
lti::gradientASM::parametersParameters for the class gradientASM
lti::panTiltUnit::parametersParameters for the class panTiltUnit
lti::ioPNG::parametersParameter class of the ioBMP class
lti::gradientFunctor::parametersParameters for the class gradientFunctor
lti::blobEM::parametersParameters for the class blobEM
lti::quickCam::parametersParameters for the quick-cam functor
lti::sonyEviD100P::parametersParameters for the class sonyEviD100P
lti::toUCam::parametersFrameGrabber parameters class
lti::uciDataReader::parametersParameters for the class uciDataReader
lti::expandVector::parametersParameters for the class expandVector
lti::studentDistribution::parametersThe parameters for the class studentDistribution
lti::blueScreen::parametersParameters for the class blueScreen
lti::bagging::parametersParameters for the class bagging
lti::ioImage::parametersParameter class of the ioImage class
lti::borderExtrema::parametersParameters for the class borderExtrema
lti::microEnablePulnix::parametersFrameGrabber parameters class
lti::kernelFunctor< T >::parametersParameters for the class distanceFunctor
lti::directedPerceptionPTU::parametersThe parameters for the class DirectedPerceptionPTU
lti::borderSignature::parametersParameters for the class borderSignature
lti::gHoughTransform::parametersParameters for the class houghTransform
lti::backSubstitution< T >::parametersParameters for the class backSubstitution
lti::quickPartialSort< T >::parametersThe parameters for the class quickPartialSort
lti::fastSVD< T >::parametersFastSVD parameter class
lti::ioLTI::parametersParameter class of the ioLTI class
lti::boundsFunctor< T >::parametersParameters for the class boundsFunctor
lti::boundingBox< T >::parametersParameters for the class boundingBox
lti::chiSquareFunctor::parametersParameters for the class chiSquareFunctor
lti::ioBMP::parametersParameter class of the ioBMP class
lti::choleskyDecomposition< T >::parametersParameters for the class choleskyDecomposition
lti::fundamentalMatrixSolverLMS::parametersParameters for the class fundamentalMatrixSolverLMS
lti::continuousRandomDistribution::parametersParameters of the random distribution
lti::brightRGB::parametersParameters for the class brightRGB
lti::serialVectorStats< T >::parametersParameters for the class serialVectorStats
lti::serialStatsFunctor< T, U >::parametersParameters for the class meansFunctor
lti::coordinateTransformation::parameters------------------------------------------------------------------ start of parameters The parameters for the class coordinateTransformation
lti::hessianFunctor::parametersThe parameters for the class hessianFunctor
lti::featureExtractor::parametersParameters for the class featureExtractor
lti::scramble< T >::parametersParameters for the class scramble (empty)
lti::cubicSpline< T >::parametersParameters for the class cubicSpline
lti::locationSearchEvaluation::parametersThe parameters for the class locationSearchEvaluation
lti::maximumFilter< T >::parametersParameters for the class maximumFilter
lti::validator::parametersParameters for the class validator
lti::calibrationBlobFeatures::parametersParameters for the class calibrationBlobFeatures
lti::delaunayTriangulation< T >::parametersParameters for the class delaunayTriangulation
lti::loweGradientFeature::parametersThe parameters for the class loweGradientFeature
lti::generalEigenVectors< T >::parametersEigenSystem parameter class
lti::discreteRandomDistribution::parametersParameters of the random distribution
lti::DistanceFromPixel::parametersThe parameters for the class DistanceFromPixel
lti::poissonDistribution::parametersParameters class for the poisson distribution
lti::colorModelSelector::parametersParameters for the class colorModelSelector
lti::orientationFeature::parametersParameters for the class orientationFeature
lti::similarityMatrix::parametersParameters for the class similarityMatrix
lti::camshiftTracker::parametersParameters for the class camshiftTracker
lti::histograming1D::parametersParameters for the class histograming1D
lti::histogramRGBL::parametersParameters for the class histogramRGBL
lti::eigenSystem< T >::parametersEigenSystem parameter class
lti::hmmTrellisDiagram::parametersParameters for the class hmmTrellisDiagram
lti::jacobi< T >::parametersEigenSystem parameter class
lti::entropyFunctor< T >::parametersParameters for the class entropyFunctor
lti::homography8DofEstimator::parametersThe parameters for the class homography8DofEstimator
lti::equallySpacedSamplesInterpolator::parametersParameters for the class equallySpacedSamplesInterpolator
lti::cannyEdges::parametersParameters for the class cannyEdges
lti::homography9DofEstimator::parametersThe parameters for the class homography9DofEstimator
lti::decompositionSolution< T >::parametersDecompositionSolution parameter class
lti::quickMedian< T >::parametersThe parameters for the class quickMedian
lti::colorACASegmentation::parametersThe parameters for the class colorACASegmentation
lti::qrSolution< T >::parametersQrSolution parameter class
lti::homographyEstimatorBase::parametersThe parameters for the class homographyEstimatorBase
lti::euclideanSimilarity< T >::parametersParameters for the class similarityFunctor
lti::cartesianToPolar< T >::parametersParameters for the class cartesianToPolar
lti::chromaticityHistogram::parametersParameters for the class chromaticityHistogram
lti::classificationStatistics::parametersParameters for the class classificationStatistics
lti::fastEigenSystem< T >::parametersEigenSystem parameter class
lti::kullbackContrast::parametersParameters for the class kullbackContrast
lti::sort2< T, U >::parametersThe parameters for the class sort
lti::linearRegression< T >::parametersParameters for the class linearRegression
lti::channelStatistics::parametersParameters for the class channelStatistics
lti::fMatrixEstimator::parametersThe parameters for the class fMatrixEstimator
lti::hmmOnlineClassifier::parametersParameters for the class hmmOnlineClassifier
lti::chrominanceModelEstimator::parametersThe parameters for the class chrominanceModelEstimator
lti::chrominanceMapMasking::parametersThe parameters for the class chrominanceMapMasking
lti::radialKernel::parametersParameters for the class distanceFunctor
lti::lvq::parametersParameters for the class classifier
lti::gaussianDistribution::parametersParameters for gaussian distribution
lti::chrominanceMapEstimator::parametersParameters for the class chrominanceModelEstimator
lti::medianCut::parametersParameters for the class medianCut
lti::whiteningSegmentation::parametersParameters for the class whiteningSegmentation
lti::gaussianMixtureModel< T >::parametersThe parameters for the class gaussianMixtureModel
lti::generalizedEigenSystem< T >::parametersParameters for the class generalizedEigenSystem
lti::isotropicNormalization::parametersThe parameters for the class isotropicNormalization
lti::fastGeneralizedEigenSystem< T >::parametersParameter class for fastGeneralizedEigenSystem
lti::kalmanFilter::parametersThe parameters for the class kalmanFilter
lti::loadImageList::parametersParameters for the class loadImageList
lti::kalmanTracker::parametersThe parameters for the class kalmanTracker
lti::kMColorQuantization::parametersParameters for the class kMColorQuantization
lti::susanEdges::parametersParameter class for susanEdges
lti::interpolator::parametersParameters for the class interpolator
lti::kMeansSegmentation::parametersParameters for the class kMeansSegmentation
lti::symmetricMatrixInversion< T >::parametersParameters for the class symmetricMatrixInversion
lti::kNearestNeighFilter::parametersParameters for the class kNearestNeighFilter
lti::kernelPCA::parametersParameters for the class principalComponents
lti::computePalette::parametersParameters for the class computePalette
lti::classifier::parametersParameters for the class classifier
lti::labelAdjacencyMap::parametersParameters for the class labelAdjacencyMap
lti::coilBackgroundSegmentation::parametersParameters for the class coilBackgroundSegmentation
lti::linearMapperFunctor< Tin, Tout >::parametersParameters for the class linearMapperFunctor
lti::activeShapeModel::parametersParameters for the class activeShapeModel
lti::linearSatMapperFunctor< Tin, Tout >::parametersParameters for the class linearSatMapperFunctor
lti::classicEdgeDetector::parametersThe parameters for the class classicEdgeDetector
lti::mathFunction::parametersParameters for the class mathFunction
lti::opponentColor::parametersParameters for the class opponentColor
lti::colorEdgesGS::parametersParameters for the class colorEdgesGS
lti::url::parametersParameters for the url-object
lti::randomDistribution::parametersParameters of the random distribution
lti::localMoments::parametersThe parameters for the class localMoments
lti::lkmColorQuantization::parametersParameters for the class lkmColorQuantization
lti::cyclicTridiagonalEquationSystem< T >::parametersCyclicTridiagonalEquationSystem parameter class
lti::polynomRoots::parametersParameters for the class polynomRoots
lti::locationSelector::parametersParameters for the class locationSelector
lti::qrDecomposition< T >::parametersThe parameters for the class qrDecomposition
lti::colorNormalizationBase::parametersParameters for the class colorNormalizationBase
lti::maskImage::parametersParameters for the class maskImage
lti::manualCrispDecisionTree::parametersParameters for the class manualCrispDecisionTree
lti::linearAlgebraFunctor::parametersParameters for the linear algebra functors
lti::scalarFunctor< T >::parametersScalar value parameter needed in scalar functors
lti::meanShiftSegmentation::parametersParameters for the class meanShiftSegmentation
lti::colorQuantization::parametersParameters for the class colorQuantization
lti::serialPCA< T >::parametersParameters for the class serialPCA
lti::comprehensiveColourNormalization::parametersParameters for the class comprehensiveColourNormalization
lti::meanshiftTracker::parametersParameters for the class meanshiftTracker
lti::classifier::parametersOutOfRangeExceptionException thrown when a parameter is out of range
lti::paretoFrontPareto Front computation with PESA
lti::paretoFrontTesterThe Pareto Front Tester functor is a simple example of an evaluation framework using the Pareto Front class
lti::patternDraw< T >Object for drawing lines and points in a lti::matrix with support for line and fill patterns
lti::lncFeatureFile::patternIdThe ID of a class is determined with three attributes:
lti::pdmGeneratorThis class creates a pointDistributionModel (PDM) given a set of shapes of type pointDistributionModel::shape
lti::plusLTakeAwayRThis class implements the plus l - take away r algorithm descripted in: P
lti::pointDistributionModelThis class is the data structure for a Point Distribution Model (PDM)
lti::kNNClassifier::pointInfoInformation about a feature point
lti::pointSetNormalizationA parent class for normalizations of point sets
lti::poissonDistributionPoisson distributed random number class
lti::polarToCartesian< T >Computes the elements of the cartesian coordinate system (real,imaginary) based on the parameters of the polar coordinate system (absolute value, phase)
lti::polygonApproximationComputes a polygon approximation for a given border point list
lti::polygonPointsPolygon Points of Integer Points
lti::polynomialKernelThis class defines a polynomial kernel functor
lti::polynomRootsFind the roots of a polygon with real coefficients
lti::prewittKernelX< T >Prewitt Kernel X
lti::prewittKernelXX< T >Prewitt Kernel XX
lti::prewittKernelXY< T >Prewitt Kernel XY
lti::prewittKernelY< T >Prewitt Kernel Y
lti::prewittKernelYY< T >Prewitt Kernel YY
lti::principalComponents< T >Functor for computing a principal component analysis
lti::priorityQueue< T, U >Simple priority queue data class
lti::probabilityMapProbability Map based on 3D non-parametric (color) models
lti::probabilityMap2DProbability Map based on 2D non-parametric (color) models
lti::probabilityMapBaseBase class for all probability map classes, e.g
lti::processInfoLTI-Lib process info class
lti::processInfo::procStatusSystem depended structure
lti::progressInfoProgress information interface
lti::stdLayer::propagationFunctorParent class for all propagation functors All propagation functors use a given activation function to calculate the output layer vector using a given input vector and a given weights matrix
lti::pseudoInverseMP< T >This functor calculates the Moore-Penrose Pseudo-Inverse of a matrix
lti::pyramid< T >Pyramid class
lti::pyramidLocationSearchSearch for salient locations in the scale space of a channel
lti::qmfThis class implements dyadic wavelet-transform as quadrature mirror filters
lti::qmfEnergyThe qmfEnergy is a functor for extraction of texture features
lti::qmfInverseThis class allows the reconstruction of channels which were wavelet- transformed by the functor lti::qmf
lti::qrDecomposition< T >This functor computes a QRDecomposition of a given rectangular m x n Matrix A of the Form:
lti::qrSolution< T >QR solution functor
lti::quadTreeSegmentationQuad-Tree based color image segmentation method
lti::quickCamClass to access the quick cam camera system (for LINUX only!)
lti::quickMedian< T >This class is used to extract the median of the elements of a given vector or matrix
lti::quickMedian2< T, U >This class is used to extract the median of the elements of a given vector or matrix, partitioning at the same time a second vector
lti::quickPartialSort< T >Quick partial sort
lti::quickPartialSort2< T, U >Quick partial sort with colateral effects
lti::radialKernelThis class defines a radial kernel functor
lti::lvq::randInitFunctorRandom initialization
lti::randomDistributionBase random number class
lti::ransacEstimatorThis class estimates a transform using the Ransac algorithm
lti::hsvHistogramViewer::rayA helper class for drawing
lti::rayTraceEllipsoid< T >Ray tracing object for ellipsoids
lti::rayTraceObject< T >Abstract class parent for all objects that can be ray-traced
lti::rbfClass which implements RBF networks
lti::readWriteLockLti read-write synchronisation class
lti::realFFTA class for FFT
lti::realInvFFTA class for inverse FFT
lti::recognitionRateOfSubsetComputes the average recognition rate of a given subset of features from a data set
lti::rectLocationSmall region in an image or channel
lti::rectSide< T >Policy class to compute the size of a rectangle's side and the inverse transformation
lti::regionGraphColor< F >Functor to manipulate graphs of adjacent image regions, where the nodes of the graphs contain the mean value of the region represented by the node
lti::regionGraphColorHarisDistanceCompute the weight between two color point nodes as the euclidean distance between both points
lti::regionGraphColorMeanDistanceCompute the weight between two color point nodes as the euclidean distance between both points
lti::regionGraphFunctor< G >Functor to manipulate graphs of adjacent image regions
lti::regionGraphGray< F >Functor to manipulate graphs of adjacent image regions, where the nodes of the graphs contain the mean value of the region represented by the node
lti::regionGraphMeansNode< T >Type for adjacency graph nodes containing the mean values of each region
lti::regionGraphScalarHarisDistanceCompute the weight between two scalar nodes as the absolute value of the difference
lti::regionGraphScalarMeanDistanceCompute the weight between two scalar nodes as the absolute value of the difference
lti::regionGrowingThis class is used to segmentate an image with a regular background
lti::regionMergeThis functor uses a similarity matrix (see lti::similarityMatrix) and a threshold value given in the parameters to decide if two objects in a mask (also returned by lti::similarityMatrix or by lti::objectsFromMask) should be merged or not
lti::regionShapeFeaturesThis functor computes descriptors for shapes, decomposing a binary mask as a sum of some basis functions
lti::regionsPolygonizerThis functor takes a labeled mask and for each region therein it computes a polygon approximation of its contour
lti::regularizedPCA< T >Almost a functor for computing a principal component analysis
lti::relativeThresholdingThis class implements percentual Thresholding
lti::rgbColorAn alias for the rgbPixel type
lti::rgbPixelColor pixel representation in RGB color space
lti::rgbPixel::rgbPixelTypeThis union allows to share the memory of a 32 bit integer with the three ubytes of RGB and a alpha byte
lti::robinsonKernelX< T >Robinson Kernel X
lti::robinsonKernelXX< T >Robinson Kernel XX
lti::robinsonKernelXY< T >Robinson Kernel XY
lti::robinsonKernelY< T >Robinson Kernel Y
lti::robinsonKernelYY< T >Robinson Kernel YY
lti::robustEstimatorA parent class for estimating a transform from sets of points in a robust manner
lti::rotationRotation implements a rotation functor
lti::runLengthCodecEncodes a byte array to an array of hexadecimal digits or performs the corresponding decoding method, depending on the parameters
lti::saliencyBase class for all saliency modifiers
lti::sammonsMappingPerforms Sammon's Mapping
lti::saveBMPFunctor to save a bitmap (BMP) file
lti::saveImageThis class is used to save lti::image or lti::channel objects in files of one of the formats supported by the LTI-Lib
lti::saveJPEGFunctor for writing a lti::image to a JPEG file To save a JPEG image just initialize the parameters of the "saveJPEG" object and call the apply member
lti::saveLncClass to save lnc-files (ascii format to store feature vectors)
lti::saveLTIFunctor to save a bitmap (LTI) file
lti::savePNGFunctor to save a Protable Network graphic (PNG) file
lti::scalarFunctor< T >Base class for all scalar functors
lti::scalarProduct< T, U >Dot Product of two vectors
lti::scalarValuedInterpolation< T >This abstract class parents all interpolation functors, which are used to interpolate the values between the pixels or elements of vectors and matrices, espacially images
lti::scalarValuedInterpolatorFactory< T >This class defines a factory for interpolator functors derived from lti::scalarValuedInterpolation<T>
lti::scaleSpacePyramid< T >Image pyramid to represent the scale space
lti::scalingScaling implements a functor to rescale an image using a real valued scaling factor
lti::scene3D< T >Tool for creating three dimensional scenes
lti::scene3DViewerView a scene3D object
lti::schieleCrowley6DFeatureThis functor create huge lists of local features, that can be used to train the multidimensional receptive field histograms of Schiele and Crowley (see lti::shClassifier)
lti::scramble< T >This class is used to scramble the elements of a given vector or matrix
lti::segmentationBase class for all segmentation algorithms
lti::segmentationEvaluationPareto evaluation of segmentation functors
lti::selective2DConvolutionThis modifier is used to convolve individual points of a given channel with a arbitrary kernel2D<float> (e.g
lti::semaphoreLti semaphore class for inter-thread (not inter-process!) synchronisation
lti::sepKernel< T >Separable Kernel
lti::sequence< T >Sequence container class
lti::sequentialBackwardSearchThis class implements the sequential backward search algorithm for feature selection
lti::sequentialForwardSearchThis class implements the sequential forward search algorithm for feature selection
lti::serialThis serial class provides an unified interface to access serial ports in posix and windows operating systems
lti::serialLDA< T >Functor for iteratively computing a linear discriminant analysis
lti::serialPCA< T >Functor for sequentially computing a principal component analysis
lti::serialStatsExtFunctor< T, U >Functor which computes several kinds of means for vectors and matrices
lti::serialStatsFunctor< T, U >Functor which computes several kinds of means for vectors and matrices
lti::serialVectorStats< T >Functor which computes the statistics of a series of vectors
lti::url::serviceHandlerThis is an abstract base class for handling a kind of data service
lti::sffsImplemantation of the sequential floating forward search algorithm to select the best features from a data set
lti::shapeFeatureExtractorBase class for all clases which extract features from shapes displayed with pointLists
lti::shClassifierImplements a sparse histogram-based classifier, such as the one described in B
lti::shiftInvarianceThis functor takes a vector, which is supposed to be periodic, and generates a second "normalized" shifted one
lti::stdLayer::sigmoidActFunctorSigmoid activation function
lti::MLP::sigmoidFunctorSigmoid activation function
lti::sigmoidKernelThis class defines a "sigmoid" kernel functor
lti::MLP::signFunctorSign activation function (1.0 if input 0 or positive, -1.0 otherwise)
lti::similarityFunctor< T >This class is the base class for all functors which compute similarity measures between two vectors or matrices
lti::similarityMatrixGiven a set of connected image regions (coded in a labeled mask or std::list of area point lists) and the original color image, this functor will compute a similarity measure between the objects, and will code them in a similarity matrix
lti::earthMoversDistance< W, C, D >::single_nodeType for a single linked list
lti::hiddenMarkovModel::singleDensityThis class represents a single multivariate (ie multidimensional ) score density function within a state of a hidden markov model
lti::linearAlgebraFunctor::singularMatrixExceptionSingular matrix exception
lti::singularValueDecomp< T >Singular Value Decomposition
lti::skeletonHomotopy preserving Skeleton
lti::skinASMThis is an alignment strategy for activeShapeModels (ASM), that works on a gradient channel and a skin probability channel, to trace skin colored objects
lti::skinProbabilityMapCreates a skin probability map
lti::localColorFeature::sliceMaskSimple structure used to hold a mask and the correspoinding io-points of the circle
lti::smallObjectList< T >SmallObjectList template class
lti::snakeSnake segmentation
lti::sobelKernelX< T >Sobel Kernel X
lti::sobelKernelXX< T >Sobel Kernel XX
lti::sobelKernelXY< T >Sobel Kernel XY
lti::sobelKernelY< T >Sobel Kernel Y
lti::sobelKernelYY< T >Sobel Kernel YY
lti::SOFMThis is the base class for all Self Organizing Feature Maps
lti::SOFM2DThis is a Self-Organizing Feature Map with a 2-D grid of neurons
lti::SOFM2DVisualizerThis class provides some possibilites to visualize the given SOFM
lti::sonyEviD100PAccess to the Sony Evi D100P camera and pan tilt unit
lti::sort< T >Sort vectors
lti::sort2< T, U >Sort two vectors, using the first one as key
lti::sortExpensive< T, TValue >Sorts elements in a list that are computationally expensive to compare
lti::sortExpensive< T, TValue >::sortHelperHelper class for sorting
lti::sparseHistogramSimple sparse multidimensional histogram
lti::sparseMatrix< T >SparseMatrix container class
lti::splitImageParent for all classes that split image into differen color spaces components (color channels)
lti::splitImageFactoryThis class defines a factory for functors that split color images in their color components
lti::splitImageToCIELuvSplit image in its L$^*$u$^*$v$^*$ channels
lti::splitImageToGSCSplit image in its c1, c2 and c3 components, as described in T
lti::splitImageToGSLSplit image in its l1, l2 and l3 components, as described in T
lti::splitImageToHLSSplit image in its Hue - Luminance - Saturation channels
lti::splitImageToHSISplit image in its Hue - Saturation - Intensity channels
lti::splitImageToHSVSplit image in its Hue - Saturation - Value channels
lti::splitImageToOCPSplit image in an oponent colour system
lti::splitImageToRGBSplit image in its Red - Green - Blue channels
lti::splitImageTorgISplit image in its chromaticity channels
lti::splitImageToxyYSplit image in its xyY norm chromaticity channels
lti::splitImageToXYZSplit image in its XYZ norm channels
lti::splitImageToYCbCrComputes the YCbCr values from a given RGB color representation (rgbPixel)
lti::splitImageToYIQSplit image in its Luminance Inphase Quadrature channels
lti::splitImageToYPbPrComputes the YPbPr values from a given RGB color representation (rgbPixel)
lti::splitImageToYUVComputes the YUV values from a given RGB color representation (rgbPixel)
lti::square< T >Square functor class
lti::squareConvolution< T, A >This is an efficient implementation of the convolution with a square or rectangular kernel
lti::squareRoot< T >SquareRoot functor class apply sets each element of the T-object to it's square root
lti::lispStreamHandler::stackElementType for each element of the stack
lti::statisticsFunctorThis is the base class for all kinds of nice statistics functors
lti::statusBase class for all lti objects that can have a status text
lti::stdLayerThis abstract class implements a standard neural network layer
lti::strassenMultiplication< T >Implementation for the addtion forms:
lti::streamProgressInfoProgress Information to stream
lti::studentDistributionThe Student t-test compares the means of two normally distributed samples of sizes n1 and n2, assuming that their unknown variances are equal
lti::supervisedInstanceClassifierAbstract class, parent of all supervised instance classifiers
lti::supervisedInstanceClassifierFactoryThis class defines a factory for classifiers
lti::supervisedSequenceClassifierAbstract class, parent of all supervised classifiers for sequences
lti::susanA class for SUSAN image Processing
lti::susanCornersCorner finder with the Susan low level image processing algorithm
lti::susanDenoiseThe susan denoiser enhances pictures by removing the noise from any colour channel
lti::susanEdgesThe Susan Edge Detector
lti::susan::susanErrorSusan error exception
lti::svmImplements a support vector machine (SVM)
lti::symmetricEdgeTraits< W >Basic class for symmetric edges
lti::symmetricMatrixInversion< T >Functor for inversion of symmetric, positive definite matrices
lti::tap9Symmetric9 tap symmetric filter kernel
lti::tbox< T, S >Class to describe a 3D box aligned with the coordinate system
lti::temporalTemplateThis functor implements temporal templates, as described by James Davis and Aaron Bobick in "The Representation and Recognition of Action Using Temporal Templates", MIT Media Lab, Tech
lti::tensor< T >Tensor template class
lti::tfastLine< T >Type for computations with lines
lti::thistogram< T >Histogram template class
lti::threadLti thread class
lti::thresholdingThreshold segmentation of a single channel (monochrom) image or a contour
lti::thresholdSegmentationThreshold segmentation of a single channel (monochrom) image or a contour
lti::timerThe timer allows to measure time with a precision of about 30us on Linux systems and ??? on windows systems
lti::tline< T >Type for computations with lines
lti::coilBackgroundSegmentation::TmeanProbabilityType combining the region with its mean color, probability and relation to background and object
lti::toUCamPhilips USB ToUCam "frame grabber"
lti::tpoint< T >Two dimensional point, containing the coordinates x, y
lti::tpoint3D< T >Three dimensional point, containing the coordinates x, y and z
lti::tpointList< T >TpointList template class
lti::tpolygonPoints< T >Contour classes: polygonPoints
lti::lvq::trainFunctorBase class of training functors for the lvq networks
lti::stdLayer::trainFunctorTraining functor
lti::transformA base class for integral transformations
lti::transformEstimatorA parent class for estimating a transform from sets of points
lti::transformEstimatorFactoryThis class defines a factory for transform estimator functors
lti::translationScaleEstimatorThis class estimates a translation and common scale for the x and y coordinates, i.e
lti::trectangle< T, S >Rectangle representation class
lti::tree< T >Tree container class
lti::trgbPixel< T >Template to use RGB pixel representations of types other than ubyte
lti::draw3D< T >::triangleTriangle is the base for all other polygons
lti::triangularKernel1D< T >One-dimensional filter kernel
lti::triangularMatrixTypeThis is a helper class that defines the enum eTriangularType and has one member triangularType of that type
lti::tridiagonalEquationSystem< T >Solves a special kind of linear equation system, where only the main diagonal and the first lower and upper sub-diagonals are non-zero
lti::triMatrix< T >TriMatrix is a very simple class to optimize memory usage when using an square triangular matrix with following form:
lti::typeInfo< T >This class allows to ask some information required in the LTI-Lib for some types
lti::uciDataReaderReads data in the form as it is often found in standard data sets: Raw data either just a matrix of doubles with each row a feature vector, or rows containing feature vectors and an id as last element of the row
lti::uciDataWriterWrites data in the form as it is often found in standard data sets: Raw data either just a matrix of doubles with each row a feature vector, or rows containing feature vectors and an id as last element of the row, or raw data with or without ids and a header with the number of points and the dimensionality
lti::unifiedGeneralizedEigenSystem< T >This functor is meant to be used for solving any generalized Eigenvalue problem without need to think about the most efficient usage of the available methods
lti::unifiedSVD< T >This functor is meant to be used for calculating the Singular Vector Decomposition without need to think about the most efficient usage of the available methods
lti::unifiedSymmetricEigenSystem< T >This functor is meant to be used for solving any symmetric Eigenvalue problem without need to think about the most efficient usage of the available methods
lti::uniformDistributionUniform distributed random number class
lti::crispDecisionTree::univariateCrispDecisionFunctionThis class implements the most common decision function: Each node has a real-valued threshold in one dimension only
lti::unsupervisedClassifierAbstract class, parent of all unsupervised classifiers
lti::upsamplingUpsampling is the complementary functor to lti::downsampling
lti::urlClass for retrieving documents identified by an URL
lti::url::urlFieldsThis class is used to split a URL into its separate fields
lti::usePaletteUse color or gray-valued palette
lti::validatorChecks the validity of a matrix or vector with float or double elements
lti::variablySpacedSamplesInterpolatorThis abstract class parents all interpolation functors, whose samples have varying distances
lti::varianceFunctor< T >Functor which computes several kinds of variances for vectors and matrices
lti::lkTracker::vec2dPosition/direction vector type
lti::vector< T >Vector container class
lti::viewerUse objects of this class to display your data in a window
lti::viewerBaseAbstract class parent for all viewer objects in the LTI-Lib
lti::viewerBase3DThis is the base class for all viewer classes which show 3D data
lti::viewerFunctorThis viewerFunctor has as task to prepare an image, that will be visualized in the lti::viewer
lti::watershedSegmentationWatershed segmentation of a channel8
lti::weightedGraph< P, D, W >Weighted Graph container class
lti::whiteningSegmentationThe whitening segmentation is an extention of the k-Means based segmentation (see lti::kMeansSegmentation)

Generated on Sat Apr 10 15:26:31 2010 for LTI-Lib by Doxygen 1.6.1