lti::absoluteValue< T > | AbsoluteValue functor class |
lti::MLP::activationFunctor | Parent class for all activation function functors |
lti::stdLayer::activationFunctor | Parent class for all activation function functors |
lti::activeShapeModel | This is the base class for active shape models (ASM) |
lti::adaptiveKMeans | This 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::allocException | AllocException 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::arctanLUT | Following class provides a mono-state object that contains a 1MB Look-up Table to accelerate the computation of the arc-tangens |
lti::areaPoints | Contour classes: Area-Points |
lti::array< T > | Array class |
lti::ascii85Codec | Encodes a byte array to an array of hexadecimal digits or performs the corresponding decoding method, depending on the parameters |
lti::asciiHexCodec | Encodes 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::axLocalRegions | This functor is based on concepts described in Lowe, D.G |
lti::axOGDFeature | OGD based texture feature |
lti::backgroundModel | Implementation 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::bagging | Implementation of bagging classification |
lti::microEnablePulnix::bankType | The Pulnix Camera TMC6700 can handle up to four parameters sets |
lti::battleLemarieKernel | Battle-Lemarič filter kernel |
lti::bayerDemosaicing | This functor makes a color interpolation of common BAYER Patterns used in digital cameras |
lti::bhattacharyyaDistance | Computes the bhattacharyya distance of two distributions |
lti::bhattacharyyaDistOfSubset | The 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::binarizationCodec | Encodes a byte array to an array of bits |
lti::binaryStreamHandler | Binary stream handler |
lti::binomialDistribution | This 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::blobEM | Estimates 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::blueScreen | This functor replaces a specified background color of an image with another color or another image ("Bluescreen Technique") |
lti::borderExtrema | This functor extracts minimum and maximum positions along a border in terms of distance to a given center point |
lti::borderPoints | Contour classes: Border-Points |
lti::borderSignature | This 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::brightRGB | This 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::buffer | The buffers with the data to be transformed (or the transformed data) are manipulated in container instances of the buffer type |
lti::fireWireDCAM::busInfo | IEEE 1394 Bus Information Class |
lti::calibrationBlobFeatures | To calibrate the camera optic feature points of an calibration pattern must be extracted |
lti::camera | Parent class for all cameras with control over the lens system, including zooming |
lti::fireWireDCAM::cameraInfo | The camera information class |
lti::fireWireDCAM::cameraSet | Set of cameras |
lti::camshiftTracker | This 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::cannyEdges | The 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::centroidClustering | Base class for all clustering methods that use centroids or prototypes for describing individual clusters |
lti::chainCode | Elements of a Chaincode |
lti::channel | Format for float channels |
lti::channel32 | Format for signed 32-bit-channels |
lti::channel8 | Format for 8-bit-channels |
lti::channelStatistics | This functor splits an image into three channels of a color space set in the parameters (see parameters::setSplitter() ) |
lti::rgbPixel::rgbPixelType::channelsType | Three channels |
lti::chessBoardKernel< T > | Chessboard filter kernel or square filter kernel |
lti::chiSquareFunctor | ChiSquareFunctor 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::chromaticityHistogram | Create a chromaticity histrogram feature vector |
lti::chrominanceMapEstimator | This class computes a map between the chrominances and the most likely object based on chrominance histograms and the Bayes Theorem |
lti::chrominanceMapMasking | This 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::chrominanceModelEstimator | This class stores a 2d histogram containing all chrominances which have been seen on a specific object |
lti::cityBlockKernel< T > | CityBlock filter kernel |
lti::classicEdgeDetector | This class implements simple standard edgedectors like Sobel |
lti::classificationStatistics | This class allows the generation of classification statistics |
lti::classifier | Abstract parent class for all classifiers |
lti::classifier2DVisualizer | This functor creates beautiful pictures |
lti::className | Provides methods for getting the class names of lti::objects |
lti::sparseHistogram::cless | Comparator for C-strings (null-terminated char array) |
lti::clustering | Base class for all clustering algorithms |
lti::clusteringValidity | Parent class for all clustering validity measures |
lti::cmykColor | A little class for defining points in the CMYK color space |
lti::coilBackgroundSegmentation | The coilBackgroundSegmentation functor tries to detect which pixels belong to the background and which not |
lti::colorACASegmentation | Color Adaptive Clustering Algorithm |
lti::colorContrastGradient | The contrast gradient is used in color or multi-spectral image as a replacement of the gray-value gradient in gray images |
lti::colorDialog | Allows to choose a color in the HSI or RGB color space |
lti::colorEdgesGS | Gevers and Stokman color edges |
lti::colorModelEstimator | This functor is used to create three-dimensional histograms for the colors of images |
lti::colorModelSelector | This functor selects one color model from a set, which elements were given by addColorModel |
lti::colorNormalizationBase | Parent class for color normalization methods usually used to eliminate the effects of illumination changes |
lti::colorQuantization | Abstract parent class for all color quantization algorithms All color quantization functors must overload the apply-member defined here |
lti::combination | This class is used to combine several results of different classifier::output objects |
lti::combinedCodec | This is the base class for data encoding and decoding |
lti::competitiveAgglomeration | This 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::comprehensiveColourNormalization | This class implements the algorithm described in the paper "Comprehensive Colour Image Normalization" by Finlayson, Schiele and Crowley |
lti::computePalette | This class is used to compute a palette given a color image and an index mask |
lti::viewer::configChannelFixed | Configuration Dialog for viewer of images of fixed point scalar values, like channel8 or matrix<int> |
lti::viewer::configChannelFloat | Configuration Dialog for viewer of images of floating point scalar values, like channel or matrix<double> |
lti::viewer::configDialog | Parent class for all types of configuration dialogs for the normal viewer |
lti::histogramViewer::configDialog | GTK Widget for the configuration dialog of the histogram viewer |
lti::viewerBase3D::configDialog | GTK Widget for the configuration dialog of the histogram viewer |
lti::configFileHandler | Write and read config files, similar to windows ini files |
lti::configGTKDialog | Widget for the statistics dialog |
lti::viewer::configImage | Configuration Dialog for viewer of images of rgbPixel elements |
lti::viewer::configVector | Configuration Dialog for viewer of vectors |
lti::adjacencyGraph< N, W, D, F, E >::const_edge_iterator | The graph const_iterator iterates on all nodes in a read-only fashion |
lti::smallObjectList< T >::const_iterator | Const_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_iterator | Similar 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_iterator | Const iterator type (allows read-only operations) |
lti::adjacencyGraph< N, W, D, F, E >::const_iterator | The graph const_iterator iterates on all nodes in a read-only fashion |
lti::genericMatrix< T >::const_iterator | Const iterator type (allows read-only operations) |
lti::genericVector< T >::const_iterator | Const iterator type (allows read-only operations) |
lti::constants< T > | This class is a container of some mathematical and physical constants |
lti::genericVector< T >::constReferenceException | ConstReferenceException class |
lti::continuousRandomDistribution | Base random number class |
lti::convexHull | Computes 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::convolution | Convolution functor |
lti::coordinateTransformation | This class transforms the coordinates of a 3D point between two coordinate systems |
lti::cornerDetector | Parent class for all corner detectors |
lti::cornerDetectorFactory | This class defines a factory for corner detector functors |
lti::correlation | Correlation functor |
lti::cosinus2Similarity< T > | Quadratic Cosinus Similarity |
lti::costFunction | Base class for all cost functions |
lti::crispDecisionTree::crispDecisionFunction | Base class for decision functions of crispNode |
lti::crispDecisionTree | Base class for all crisp decision trees |
lti::crispDecisionTree::crispNode | A crisp decision tree node |
lti::crossCorrelationCoefficient | This class computes the normalized cross correlation coefficient between two matrices or vectors |
lti::crossValidator | This class does a cross validation on the given dataset and returns the average recognition rates |
lti::csPresegmentation | The 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::curvatureFeature | The 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::curvatureScaleSpace | Curvature Scale Space Representation (CSS) |
lti::cwagmSegmentation | CWAGM 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::dataCodec | This is the base class for data encoding and decoding |
lti::dataTransformer | This is the low-level base class for data transformers |
lti::daubechies16Kernel | 16 tap Daubechies filter kernel |
lti::daviesBouldinIndex | Calculates the Davies Bouldin Index of the given clustering |
lti::DBScan< T > | A class providing the DBScan for clustering |
lti::decimation | Decimation |
lti::decisionTree | This 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::defaultEndian | This 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::dilation | Dilation functor |
lti::directedPerceptionPTU | This class performs handling of the pan-tilt unit PTU-D46-17 from the manufactor DirectedPerception |
lti::discreteRandomDistribution | Base random number class |
lti::DistanceFromPixel | This 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::distancePropFunctor | Distance propagation functor |
lti::distanceTransform | This 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::dotPropFunctor | Dot-Product propagation functor |
lti::earthMoversDistance< W, C, D >::double_node | Type for a double linked list |
lti::downsampling | This 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::draw3DDistribution | Draws a three dimensional distribution |
lti::drawBase< T > | Abstract parent class for draw and epsDraw |
lti::drawFlowField | Draws the visualization of a two dimensional flowfield |
lti::decisionTree::dtNode | Simple Node for decision trees |
lti::dummyFunctor | A dummy functor that is evaluated with the paretoFront |
lti::dunnIndex | Computes 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_iterator | The edge iterator iterates on all outgoing edges of a node |
lti::edgeDetector | Parent abstract class for all edge detectors |
lti::edgeDetectorFactory | This class defines a factory for edge detector functors |
lti::edgeSaliency | A class for edge based strcutural saliency calculations |
lti::eigenSystem< T > | EigenSystem functor |
lti::snake::element | Structure for a snake element |
lti::kdTree< T, D, U >::element | At the leave nodes, a list of elements of this type will contain the points and their corresponding data |
lti::endianness | Endianness 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_type | Entry 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::equallySpacedSamplesInterpolator | This abstract class parents all interpolation functors, whose samples have equal distances to each other (per dimension) |
lti::erosion | Erosion functor |
lti::euclideanKernel< T > | Euclidean filter kernel |
lti::euclideanSimilarity< T > | Euclidean Similarity Measure |
lti::exception | Base class for all lti-library exceptions |
lti::expandVector | This 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::exponentialDistribution | Exponentially distributed random number class |
lti::sonyEviD100P::externPoll | If an user wants to send inquiries to the device and process the answers explicitly, he may obtain a reference to this class |
lti::externViewer | This object shows an image using an external application like kview, xv, mspaint, etc |
lti::faceThreshold | The 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::fastCircleExtraction | This 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::fastEllipseExtraction | This 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::fastLineExtraction | This functor implements a fast line extraction using the line segments found in digital images |
lti::geometricTransform::fastMatrix | Structure to avoid the use of the access operator of matrices |
lti::fastRelabeling | This 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::featureExtractor | The 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::featureSaliencyAx | Feature saliency map for AXIOM |
lti::featureSaliencyIK | Feature Saliency for color images |
lti::featureSelector | Abstract base class for all feature selectors |
lti::filledUpsampling | Filled Upsampling |
lti::fillPattern | Fill pattern class |
lti::filter | Base class for all filters |
lti::fireWireDCAM | Grab imags from FireWire Cameras |
lti::flipImage | Flips an image horizontally or vertically |
lti::fMatrixEstimator | A class for estimating the fundamental matrix with a least squares approach |
lti::fMatrixEstimatorBase | A base class for estimating the fundamental matrix with a least squares approach |
lti::fireWireDCAM::format7Info | Structure to hold format 7 information |
lti::fireWireDCAM::format7ModeInfo | Structure to hold format 7 mode information |
lti::forwardSubstitution< T > | Forward substitution |
lti::fourierDescriptor | This class generates fourier descriptors |
lti::frameGrabber | Frame grabber class |
lti::frameGrabber::frameGrabberException | Class for frame grabber exceptions |
lti::frankotChellapa | The Francot-Chellapa argorithm extracts a depth image from an intensity image |
lti::functionGenerator | FunctionGenerator parses input strings representing mathematical functions of the type and |
lti::functor | Base class for all lti functors |
lti::fundamentalMatrixSolverLMS | This Algorithm determines the fundamental matrix from point correnspondences in two images |
lti::fuzzyCMeans | This 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::gammaDistribution | Gamma distributed random number class |
lti::stdLayer::gaussActFunctor | Gaussian activation function |
lti::blobEM::gaussEllipse | An internal class of lti::blobEM for handling 2D gaussian ellipses |
lti::gaussian< T > | This function evaluates a multivariate gaussian with the form:
|
lti::gaussianDistribution | Normal 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::geometricFeatureGroup0 | Description of the simpliest geometric features given by the rectangle surrounding the object, the object's area and the center of gravity |
lti::geometricFeatures | Computes features, which describe some geometric properties of a 2D shape |
lti::geometricFeaturesFromMask | This 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::geometricTransform | This 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::getStreamFd | This functor can be used to access the file descriptor that is used within a stream object |
lti::gHoughTransform | The Generalized-Hough-Transform |
lti::globalFeatureExtractor | The 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::gradientASM | This class implements an alignment strategy for activeShapeModel (ASM) |
lti::gradientFunctor | The 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::graphicsPattern | GraphicsPattern template class |
lti::grayWorldNormalization | Performs a color normalization on an lti::image using a gray world approach, in order to eliminate effects of illumination colour |
lti::gtkServer | Server to administrate gtk GUI |
lti::gtkServer::guiThread | An instance of this class will be the GUI server object, called gtkServer |
lti::guyMedioniSaliency | The Guy-Medioni saliency is a procedure for perceptual grouping of low level features like points and edges |
lti::haarKernel | Haar filter kernel |
lti::harrisCorners | Harris 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::hashEntry | Entry 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::header | BITMAPFILEHEADER: |
lti::lncFeatureFile::header | Header of a lnc feature file |
lti::ioLTI::header | LTI-Format file header |
lti::hessianFunctor | The hessianFunctor calculates three channels from an input channel L: |
lti::hessianKernelXX | Two-dimensional kernels to compute the Hessian coefficients |
lti::hessianKernelXY | Two-dimensional kernels to compute the Hessian coefficients |
lti::hessianKernelYY | Two-dimensional kernels to compute the Hessian coefficients |
lti::hiddenMarkovModel | Hidden Markov Model (HMM) class |
lti::histogram1D | One dimensional histogram of type double |
lti::histogram2D | Two dimensional histogram of type double |
lti::histogramEqualization | HistogramEqualization 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::histograming1D | This class extracts a 1D histogram from a channel or channel8 |
lti::histogramRGBL | This 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::histogramViewer | This class display the histograms of images or channels |
lti::draw3D< T >::hmatrix | Homogene 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::hmmClassifier | This class defines training and classification methods for Hidden Markov Models (HMM) using observation sequences |
lti::hmmOnlineClassifier | This class allows online classification of word chains |
lti::hmmTrainer | Hidden Markov Model (HMM) trainer |
lti::hmmTrellisDiagram | Draws the trellis diagram for visualizing the viterbi path selection given by lti::hmmViterbiPathSearch for a lti::hiddenMarkovModel! |
lti::hmmViterbiPathSearch | This class finds and evaluates the best path through a Hidden Markov Model (HMM) for a given observation sequence |
lti::homography8DofEstimator | This class computes the parameters of the perspective transformation between two images using a non-homogenous approach and least squares |
lti::homography9DofEstimator | This class computes the parameters of the perspective transformation between two images using an homogenous approach and least squares |
lti::homographyEstimatorBase | A parent class for estimating a transform that can be converted to a homography |
lti::homographyEstimatorFactory | This 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::hsvHistogramViewer | A simple HSV histogram viewer |
lti::huMoments | Extracts the 7 moment invariants as described in "Visual Pattern Recognition
by Moment Invariants" by Ming-Kuei Hu (IRE Transactions on Information Theory, 1962) |
lti::identityCodec | This is a dummy codec that does absolutely nothing |
lti::image | The one and only RGB-image format |
lti::linearAlgebraFunctor::incompatibleDimensionsException | Incompatible dimensions exception |
lti::paretoFront::individual | Structure characterizing an individual |
lti::ioBMP::infoHeader | BITMAPINFOHEADER |
lti::stdLayer::initFunctor | This class and all it's derived classes should initialize the network layer |
lti::rbf::initFunctor1 | Initialization functor for rbf |
lti::rbf::initFunctor2 | Initialization functor for rbf networks |
lti::interpolator | This abstract class parents all interpolation functors |
lti::functor::invalidMethodException | Exception thrown when a method of a functor is not implemented for a specific parameter set |
lti::classifier::invalidMethodException | Exception thrown when a method of a functor is not implemented for a specific parameter set |
lti::classifier::invalidOutputException | Exception thrown when the output objects has not been set yet |
lti::viewerBase::invalidParametersException | Exception thrown when the parameters are not set |
lti::functor::invalidParametersException | Exception thrown when the parameters are not set |
lti::classifier::invalidParametersException | Exception thrown when the parameters are not set |
lti::ioBMP | Base class to functors which load and save images in BMP format |
lti::ioFunctor | Base class to all io functors |
lti::ioHandler | Input/output handlers |
lti::ioImage | Base class to functors which load and save images in all formats |
lti::ioJPEG | Base class to functors which load and save images in JPEG format |
lti::ioLTI | Base class to functors which load and save images in LTI format |
lti::ioObject | Basic input/output class for data objects |
lti::ioPNG | Base class to functors which load and save images in PNG format |
lti::ioPoints | Contour classes: IO-Points |
lti::isotropicNormalization | A class for isotropic normalizations of point sets |
lti::iteratingFunctor< T > | Base class for all iterating functors |
lti::smallObjectList< T >::iterator | Iterator 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::iterator | Similar to the iterators of the sparse matrix, these iterators allow to access the non-sparse cells of the histogram |
lti::tree< T >::iterator | Iterator type (allows read and write operations) |
lti::adjacencyGraph< N, W, D, F, E >::iterator | The graph iterator iterates on all nodes |
lti::genericMatrix< T >::iterator | Iterator type (allows read and write operations) |
lti::genericVector< T >::iterator | Iterator type (allows read and write operations) |
lti::jacobi< T > | Jacobi functor |
lti::kalmanFilter | A discrete linear Kalman filter implementation |
lti::kalmanTracker | A 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::kernelPCA | Functor 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::kMColorQuantization | K-Means based color quantization |
lti::kMeansClustering | This class implements two versions of k-means-clustering: batch and sequential |
lti::kMeansSegmentation | A segmentation algorithm which is based on a color-quantization algorithm followed by a smoothing filter |
lti::kNearestNeighFilter | A smoothness filter for label images (channel8,matrix<int>) which uses the idea of the k-Nearest Neighbour concept |
lti::kNNClassifier | Implements a k nearest neighbors search based classifier |
lti::kullbackContrast | Calculate 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::labelAdjacencyMap | Visualize a label mask in a color image |
lti::lapackInterface | Interface object for LAPACK functions |
lti::laplacianKernel | Two-dimensional kernels to compute the Laplacian |
lti::laplacianPyramid< T > | LaplacianPyramid class |
lti::lvq::layer | Lvq layer |
lti::rbf::layer1 | Layer 1 for rbf networks |
lti::rbf::layer2 | Layer 2 for rbf networks |
lti::graphicsPattern::less | A comparator used for sorting patterns |
lti::leutronFrameGrabber | Interface to all Leutron framegrabbers in the system |
lti::stdLayer::linearActFunctor | Linear activation function |
lti::MLP::linearActFunctor | Linear activation function |
lti::linearAlgebraFunctor | Base 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::linearKernel | This 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::linearRegressionTracking | With 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::linePattern | Line pattern class |
lti::lispStreamHandler | Offer an interface for the functor parameters and other classes to read() and write() them in a LISP-like format |
lti::lkmColorQuantization | Color quantization functor based on the local k-Means algorithm of O |
lti::lkTracker | This functor implements a hierachical Lucas Kanade optical flow |
lti::lncFeatureFile | Parent class for the functors which deal with the ASCII file format to store feature vectors |
lti::loadBMP | Functor to read a bitmap (BMP) file |
lti::loadImage | Functor to read an image file |
lti::loadImageList | This 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::loadJPEG | Functor 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::loadLnc | Class to load lnc-files (ascii format to store feature vectors) |
lti::loadLTI | Functor to read a bitmap (LTI) file |
lti::loadPNG | Functor to read a Portable Network Graphic (PNG) file |
lti::loadVectorImageList | This 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::localColorFeature | This functor calculates for each location in a given list color-features |
lti::localFeatureExtractor | The 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::localMoments | This 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::location | Small region in an image or channel |
lti::locationSearchEvaluation | Pareto evaluation of the lti::pyramidLocationSearch functor |
lti::locationSelector | This functor adjust the given list of locations by a given mask |
lti::logarithm< T > | Logarithm functor class |
lti::loweGradientFeature | Local 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::luvPixel | Like rgbPixel for RGB-ColorSpace, is luvPixel for LUV-ColorSpace |
lti::lvq | LVQ-Net |
lti::lvq::lvq1TrainFunctor | LVQ1 |
lti::lvq::lvq3TrainFunctor | LVQ3 |
lti::lvq::lvq4TrainFunctor | LVQ4 |
lti::mahalanobisDistance | This class computes the mahalanobis distance |
lti::mahalanobisDistOfSubset | This class implements a cost function for evaluating a subset of features based on the mahalanobis distance |
lti::mainGTKWindow | This class encapsulates all signals and calls of the GTK library |
lti::histogramViewer::mainWindow | GTK Widget for the main class of the histogram viewer |
lti::scene3DViewer::mainWindow | GTK Widget for the main class of the histogram viewer |
lti::viewer::mainWindow | Abstract class for all main windows for the different data types |
lti::viewerBase3D::mainWindow | Widget for the main class of the histogram viewer |
lti::viewer::mainWndChannelFixed | Main Window for channels of fixed point values |
lti::viewer::mainWndChannelFloat | Main Window for channels of floating point values |
lti::viewer::mainWndImage | Main Window for color images |
lti::viewer::mainWndVector | Main Window for vectors |
lti::manualCrispDecisionTree | This 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::maskImage | This 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::mathFunction | Abstract class, used as parent for all mathematical parametrical functions, like multi-variate gaussians |
lti::mathObject | Base object for the math-classes |
lti::matrix< T > | Mathematical matrix container class |
lti::matrixInversion< T > | Matrix inversion functor |
lti::lapackInterface::matrixNotConnected | Exception class denoting an illegal matrix format (non-connected) All matrices used by LAPACK routines must be connected |
lti::lvq::maxDistInitFunctor | Maximum 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::meanShiftSegmentation | This is the implementation of the mean shift segmentation algorithm |
lti::meanshiftTracker | This 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::medianCut | This class does color quantization with median-cut-algorithm (Heckbert, MIT 1980) |
lti::medianFilter | This class implements the median filter |
lti::mergeCIELuvToImage | Merge CIE Luv channel into an color image |
lti::mergeHLSToImage | Merge HLS channels (Hue, Luminance, Saturation) |
lti::mergeHSIToImage | Merge HSI (Hue Saturation Intensity) channels |
lti::mergeHSVToImage | Merge HSV channels (Hue, Saturation, Value) |
lti::mergeImage | Base class for all merge image functor-classes |
lti::mergeOCPToImage | Merge linear opponent color channels OCP |
lti::mergeRGBToImage | Merge RGB channels |
lti::mergergIToImage | Merge chromaticity channels rgI |
lti::mergexyYToImage | Merge chromaticity xyY channels |
lti::mergeXYZToImage | Merge XYZ channels |
lti::mergeYCbCrToImage | Creates 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::mergeYIQToImage | Merge YIQ channels (Luminance, Inphase, Quadrature) |
lti::mergeYPbPrToImage | Creates 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::mergeYUVToImage | Compute 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::microEnablePulnix | Silicon 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::MLP | Multi-layer perceptrons |
lti::modHubertStat | Calculates the modified Hubert statistic of the given clustering |
lti::modifier | Base class for all filters and other functors, which transform an image or channel in another image of the same type |
lti::monteCarloEstimator | A parent class for estimating a transform from point sets while detecting and discarding outliers |
lti::morphology | Base class for all morphological operators |
lti::MSTClustering< U > | This class implements a minimum spanning tree clustering |
lti::multiclassNormalizedCuts | Multiclass normalized cuts |
lti::multiGeometricFeaturesFromMask | This 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::multivariateCrispDecisionFunction | This class implements a multivariate decision |
lti::multivariateGaussian | This class generates either one point from a given covarianceMatrix and centre or it generates a given number of points according to these parameters |
lti::mutex | Lti mutex class |
lti::fireWireDCAM::nameDB | Camera database |
lti::colorModelSelector::namedModel | Internal 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 >::node | The elements of the tree are instances of the "node" class |
lti::weightedGraph< P, D, W >::node | Elements of the graph are instances of this class |
lti::kdTree< T, D, U >::node | Class of nodes of the kd-tree |
lti::tree< T >::nodeManager | The nodeManager takes care of the memory administration |
lti::noise< T > | Noise class |
lti::nonMaximaSuppression | The 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::normModHubertStat | Calculates the normalized version of the modified Hubert statistic The index is between -1 and 1 |
lti::object | Base class for all lti objects |
lti::objectFactory< T > | This class defines a factory for objects |
lti::objectsFromMask | This class works on channel8/imatrix to extract connected components and describes them as the topological order of "objects" and "holes" |
lti::objectsFromMask::objectStruct | This 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::ogdFilter | Oriented gaussian derivatives steerable filters |
lti::lvq::olvq1TrainFunctor | OLVQ1 |
lti::lvq::olvq3TrainFunctor | OLVQ3 |
lti::opponentColor | This functor generates an "opponent color" channel from the given two channels, one representing the center, the other representing the surround |
lti::endianness::oppositeEndian | If file endianness is the opposite as the system endianness |
lti::opticalFlowHS | Computes the optical flow between two consecutive images according to Horn-Schunks gradient based method |
lti::opticalFlowLK | This class computes the optical flow between two consecutive images according to the gradient based method of Lucas+Kanade |
lti::optimalThresholding | Threshold segmentation of a single channel with the optimal threshold value |
lti::orientationFeature | The 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::orientationMap | Generate an orientation map of a given channel |
lti::orientedHLTransform | This functor is used to make a fast Hough Line Transform and creates a channel32 transformation accumulator |
lti::classifier::outputTemplate | The outputTemplate stores the relation between the different positions (sometimes called internal ids) of a classification result and the ids |
lti::classifier::outputVector | An output vector is the result of classifying data with any classifier |
lti::overlappingSets2D | Considering 2d sets, which may overlap, one might ask in which sets a particular 2d point is contained |
lti::viewerBase3D::configDialog::pageWidget | Structure used in the elements of the list of all pages of the configuration dialog |
lti::ioBMP::palette | Color Palette |
lti::panTiltUnit | Parent class for all pan tilt units |
lti::similarityFunctor< T >::parameters | Parameters for the class similarityFunctor |
lti::configFileHandler::parameters | Parameters for the class configFileHandler |
lti::functor::parameters | Base class for all lti parameter objects |
lti::featureSaliencyIK::parameters | Parameters for the class featureSaliencyIK |
lti::hsvHistogramViewer::parameters | Parameters for the class hsvHistogramViewer |
lti::sort< T >::parameters | The parameters for the class sort |
lti::medianFilter::parameters | Parameters for the class medianFilter |
lti::distanceFunctor< T >::parameters | Parameters for the class distanceFunctor |
lti::globalFeatureExtractor::parameters | Parameters for the class globalFeatureExtractor |
lti::guyMedioniSaliency::parameters | Parameters for the class guyMedioniSaliency |
lti::transform::parameters | Transform Functor parameters class |
lti::classifier2DVisualizer::parameters | Parameters for the class classifier2DVisualizer |
lti::backgroundModel::parameters | Parameters for the class backgroundModel |
lti::convexHull::parameters | Parameters for the class convexHull |
lti::singularValueDecomp< T >::parameters | Parameters for the class |
lti::kMeansClustering::parameters | Parameters for kMeansClustering |
lti::MLP::parameters | Parameters for the class MLP |
lti::harrisCorners::parameters | Parameters for the class harrisCorners |
lti::MSTClustering< U >::parameters | Parameters for the class MSTClustering |
lti::convolution::parameters | Parameters of the lti::convolution functor |
lti::variablySpacedSamplesInterpolator::parameters | Parameters for the class variablySpacedSamplesInterpolator |
lti::binomialDistribution::parameters | Parameters for the class binomialDistribution |
lti::unifiedGeneralizedEigenSystem< T >::parameters | Parameters for the class unifiedGeneralizedEigenSystem |
lti::modifier::parameters | Parameter class for modifier |
lti::grayWorldNormalization::parameters | The parameters for the class grayWorldNormalization |
lti::flipImage::parameters | Parameters for the class flipImage |
lti::monteCarloEstimator::parameters | The parameters for the class monteCarloEstimator |
lti::uniformDistribution::parameters | Parameters class for the uniform distribution |
lti::uciDataWriter::parameters | Parameters for the class uciDataWriter |
lti::clustering::parameters | Parameters for clustering functors |
lti::morphology::parameters | Parameters for the class morphology |
lti::plusLTakeAwayR::parameters | Parameters for the class plusLTakeAwayR |
lti::multiclassNormalizedCuts::parameters | Parameters for the class multiclassNormalizedCuts |
lti::cornerDetector::parameters | Parameters for the class cornerDetector |
lti::getStreamFd::parameters | Parameters for the class streamAccess |
lti::squareConvolution< T, A >::parameters | Parameters for the class squareConvolution |
lti::nonMaximaSuppression::parameters | Parameters for the class nonMaximaSuppression |
lti::polynomialKernel::parameters | Parameters for the class kernelFunctor |
lti::serial::parameters | Parameters for the class serial |
lti::objectsFromMask::parameters | Parameters for the class objectsFromMask |
lti::correlation::parameters | Parameters of the lti::correlation functor |
lti::translationScaleEstimator::parameters | The parameters for the class translationScaleEstimator |
lti::externViewer::parameters | Parameters for the externViewer-object |
lti::ogdFilter::parameters | Parameters for all ogd filters |
lti::filledUpsampling::parameters | Parameters for the class upsampling |
lti::opticalFlowHS::parameters | Parameters for the class opticalFlowHS |
lti::scene3DViewer::parameters | Parameters for the class viewerBase3D |
lti::viewer::parameters | The parameters for the class viewer |
lti::opticalFlowLK::parameters | Parameters for the class opticalFlowLK |
lti::optimalThresholding::parameters | Parameters for the class optimalThresholding |
lti::crossCorrelationCoefficient::parameters | The parameters for the class crossCorrelationCoefficient |
lti::hmmTrainer::parameters | Parameters for the class hmmTrainer |
lti::viewerBase::parameters | Base class for all lti parameter objects |
lti::fuzzyCMeans::parameters | Parameters for the class fuzzyCMeans |
lti::viewerBase3D::parameters | The parameters for the class viewerBase3D |
lti::curvatureFeature::parameters | Parameters for the class curvatureFeature |
lti::overlappingSets2D::parameters | The parameters for the class overlappingSets2D |
lti::loadVectorImageList::parameters | The parameters for the class loadVectorImageList |
lti::rbf::parameters | Parameters class for the RBF-Networks |
lti::pdmGenerator::parameters | Parameters for the class pdmGenerator |
lti::curvatureScaleSpace::parameters | Parameters for the class curvatureScaleSpace |
lti::linearDiscriminantAnalysis< T >::parameters | Parameters for the class linearDiscriminantAnalysis |
lti::pointSetNormalization::parameters | The parameters for the class pointSetNormalization |
lti::cwagmSegmentation::parameters | Parameters for the class cwagmSegmentation |
lti::polarToCartesian< T >::parameters | Parameters for the class polarToCartesian |
lti::meansFunctor< T >::parameters | Parameters for the class meansFunctor |
lti::qmf::parameters | Parameters for the class qmf |
lti::skinASM::parameters | Parameters for the class skinASM |
lti::polygonApproximation::parameters | Parameters for the class polygonApproximation |
lti::segmentationEvaluation::parameters | The parameters for the class segmentationEvaluation |
lti::geometricFeaturesFromMask::parameters | Parameters for the class geometricFeaturesFromMask |
lti::probabilityMap::parameters | The parameters for the class probabilityMap |
lti::adaptiveKMeans::parameters | Parameters for the class adaptiveKMeans |
lti::fireWireDCAM::parameters | The parameters for the class fireWireDCAM |
lti::statisticsFunctor::parameters | Parameters for the class statisticsFunctor |
lti::hmmClassifier::parameters | Parameters for the class hmmClassifier |
lti::pyramidLocationSearch::parameters | The parameters for the class pyramidLocationSearch |
lti::snake::parameters | Parameters for the snakes |
lti::frameGrabber::parameters | FrameGrabber parameters class |
lti::distanceTransform::parameters | Parameters for the class distanceTransform |
lti::scalarValuedInterpolation< T >::parameters | Parameters for the class scalarValuedInterpolation |
lti::serialStatsExtFunctor< T, U >::parameters | Parameters for the class meansFunctor |
lti::recognitionRateOfSubset::parameters | Parameters for the class recognitionRateOfSubset |
lti::genericInterpolator< T >::parameters | The parameters for the class genericInterpolator |
lti::qmfEnergy::parameters | Parameters for the class qmfEnergy |
lti::ioFunctor::parameters | IoFunctor parameters class |
lti::thresholdSegmentation::parameters | Parameters for the class thresholdSegmentation |
lti::fastRelabeling::parameters | Parameters for the class fastRelabeling |
lti::downsampling::parameters | Parameters for the class downsampling |
lti::unifiedSymmetricEigenSystem< T >::parameters | Parameters for the class unifiedSymmetricEigenSystem |
lti::varianceFunctor< T >::parameters | Parameters for the class varianceFunctor |
lti::sammonsMapping::parameters | Parameters for the class sammonsMapping |
lti::quadTreeSegmentation::parameters | The parameters for the class quadTreeSegmentation |
lti::combination::parameters | Parameters for the class combination |
lti::ransacEstimator::parameters | The parameters for the class ransacEstimator |
lti::realFFT::parameters | Parameter class of the realFFT class |
lti::upsampling::parameters | Parameters for the class upsampling |
lti::unifiedSVD< T >::parameters | Parameters for the class unifiedSVD |
lti::draw2DDistribution< T >::parameters | Parameters for the class draw2DDistribution |
lti::featureSaliencyAx::parameters | Parameters for the class featureSaliencyAx |
lti::histogramViewer::parameters | Parameters for the class viewerBase3D |
lti::draw3D< T >::parameters | Parameters for draw3D |
lti::sffs::parameters | Parameters for the class sffs |
lti::regionGrowing::parameters | The parameters for the class regionGrowing |
lti::regionMerge::parameters | Parameters for the class regionMerge |
lti::competitiveAgglomeration::parameters | The parameters for the class competitiveAgglomeration |
lti::regionShapeFeatures::parameters | Parameters for the class regionShapeFeatures |
lti::regionsPolygonizer::parameters | Parameters for the class regionsPolygonizer |
lti::susanDenoise::parameters | Parameters for the class susanDenoise |
lti::probabilityMapBase::parameters | Parameters for the class probabilityMapBase |
lti::shClassifier::parameters | Parameters for the class shClassifier |
lti::tridiagonalEquationSystem< T >::parameters | TridiagonalEquationSystem parameter class |
lti::lncFeatureFile::parameters | LncFeatureFile parameters class |
lti::edgeDetector::parameters | Parameters for the class edgeDetector |
lti::SOFM2DVisualizer::parameters | Parameters for the class SOFM2DVisualizer |
lti::robustEstimator::parameters | The parameters for the class robustEstimator |
lti::rotation::parameters | Parameters for the class rotation |
lti::ioJPEG::parameters | Parameter class of ioJPEG |
lti::drawFlowField::parameters | Parameters for the class drawFlowField |
lti::saliency::parameters | parameters class for lti::saliency objects |
lti::susanCorners::parameters | Parameters for the class susanCorners |
lti::geometricTransform::parameters | The parameters for the class geometricTransform |
lti::leutronFrameGrabber::parameters | Parameters for the class leutronFrameGrabber |
lti::scaling::parameters | The parameters for the class scaling |
lti::schieleCrowley6DFeature::parameters | Parameters for the class schieleCrowley6DFeature |
lti::fastICA< T >::parameters | The parameters for the class fastICA |
lti::gaussian< T >::parameters | Parameters for the class gaussian |
lti::SOFM2D::parameters | Parameters for the class SOFM2D |
lti::fastCircleExtraction::parameters | Parameters for the class fastCircleExtraction |
lti::erosion::parameters | Parameters for the class erosion |
lti::localColorFeature::parameters | The parameters for the class localColorFeature |
lti::earthMoversDistance< W, C, D >::parameters | Parameters for the class earthMoversDistance |
lti::orientedHLTransform::parameters | Parameters for the class orientedHLTransform |
lti::faceThreshold::parameters | The parameters for the class faceThreshold |
lti::segmentation::parameters | Parameters for all segmentation algorithms |
lti::localMaxima< T >::parameters | Parameters for the class localMaxima |
lti::selective2DConvolution::parameters | Parameters for the class selective2DConvolution |
lti::shapeFeatureExtractor::parameters | Parameters for the class shapeFeatureExtractor |
lti::shiftInvariance::parameters | Parameters for the class shiftInvariance |
lti::minimumSpanningTree< K, V, Distantor >::parameters | Parameters for the class minimumSpanningTree |
lti::skeleton::parameters | Parameters for the class skeleton |
lti::localFeatureExtractor::parameters | The parameters for the class localFeatureExtractor |
lti::serialLDA< T >::parameters | Parameters for the class serialLDA |
lti::noise< T >::parameters | ScalarParameter class |
lti::geometricFeatures::parameters | Parameters for the class geometricFeatures |
lti::principalComponents< T >::parameters | Parameters for the class principalComponents |
lti::multivariateGaussian::parameters | Parameters for the class multivariateGaussian |
lti::fastEllipseExtraction::parameters | Parameters for the class fastEllipseExtraction |
lti::edgeSaliency::parameters | Parameters for the class edgeSaliency |
lti::dummyFunctor::parameters | The parameters for the class dummyFunctor |
lti::decimation::parameters | Parameters for the class decimation |
lti::fastLineExtraction::parameters | Parameters for the class fastLineExtraction |
lti::crossValidator::parameters | Parameters for the class crossValidator |
lti::SOFM::parameters | Parameters for the class SOFM |
lti::dilation::parameters | Parameters for the class dilation |
lti::temporalTemplate::parameters | Parameters for the class temporalTemplate |
lti::thresholding::parameters | Parameters for the class thresholding |
lti::transformEstimator::parameters | The parameters for the class transformEstimator |
lti::watershedSegmentation::parameters | Parameters for the class watershedSegmentation |
lti::crispDecisionTree::parameters | Parameters for the class crispDecisionTree |
lti::paretoFront::parameters | The parameters for the class paretoFront |
lti::filter::parameters | Parameters class for the filters |
lti::forwardSubstitution< T >::parameters | Parameters for the class forwardSubstitution |
lti::binarizationCodec::parameters | The parameters for the class binarizationCodec |
lti::usePalette::parameters | Parameters for the class usePalette |
lti::unsupervisedClassifier::parameters | Parameters 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 >::parameters | Parameters for the generation of scaleSpace pyramids |
lti::linearKernel::parameters | Parameters for the class distanceFunctor |
lti::decisionTree::parameters | Parameters for the class decisionTree |
lti::fMatrixEstimatorBase::parameters | The parameters for the class fMatrixEstimatorBase |
lti::huMoments::parameters | Parameters for the class huMoments |
lti::sigmoidKernel::parameters | Parameters for the class distanceFunctor |
lti::histogramEqualization::parameters | Parameters for the class histogramEqualization |
lti::minimizeBasis< T >::parameters | MinimizeBasis parameter class |
lti::functionGenerator::parameters | The parameters for the class functionGenerator |
lti::regionGraphFunctor< G >::parameters | Parameters for the class regionGraphFunctor |
lti::frankotChellapa::parameters | Parameters for the class frankotChellapa |
lti::linearRegressionTracking::parameters | Parameters for the class linearRegressionTracking |
lti::DBScan< T >::parameters | Parameters for the class DBScan |
lti::fourierDescriptor::parameters | Parameters for the class fourierDescriptor |
lti::dataCodec::parameters | The parameters for the class dataTransformer |
lti::axOGDFeature::parameters | The parameters for the class axOGDFeature |
lti::draw3DDistribution::parameters | Parameters for the class draw3DDistribution |
lti::gammaDistribution::parameters | Parameters for the gamma distribution |
lti::colorContrastGradient::parameters | Parameters for the class gradientFunctor |
lti::relativeThresholding::parameters | Parameters for the class relativeThresholding |
lti::axLocalRegions::parameters | Parameters for the class axLocalRegions |
lti::mapperFunctor< Tin, Tout >::parameters | Parameters for the class mapperFunctor |
lti::orientationMap::parameters | Parameters for the class orientationMap |
lti::camera::parameters | Parameters for the class camera |
lti::bayerDemosaicing::parameters | The parameters for the class bayerDemosaicing |
lti::featureSelector::parameters | Parameters for the class featureSelector |
lti::svm::parameters | Parameters for the class svm |
lti::csPresegmentation::parameters | Parameters for the class csPresegmentation |
lti::pseudoInverseMP< T >::parameters | Parameters for the class pseudoInverseMP |
lti::lkTracker::parameters | Parameters for the class lkTracker |
lti::matrixInversion< T >::parameters | parameters class for lti::matrixInversion functor |
lti::probabilityMap2D::parameters | Parameters for the class probabilityMap2D |
lti::multiGeometricFeaturesFromMask::parameters | Parameters for the class multiGeometricFeaturesFromMask |
lti::regularizedPCA< T >::parameters | Parameters for the class regularizedPCA |
lti::saveLnc::parameters | LncFeatureFile parameters class |
lti::kNNClassifier::parameters | Parameters for the class kNNClassifier |
lti::skinProbabilityMap::parameters | Parameters for the class skinProbabilityMap |
lti::colorModelEstimator::parameters | The parameters for the class colorModelEstimator |
lti::gradientASM::parameters | Parameters for the class gradientASM |
lti::panTiltUnit::parameters | Parameters for the class panTiltUnit |
lti::ioPNG::parameters | Parameter class of the ioBMP class |
lti::gradientFunctor::parameters | Parameters for the class gradientFunctor |
lti::blobEM::parameters | Parameters for the class blobEM |
lti::quickCam::parameters | Parameters for the quick-cam functor |
lti::sonyEviD100P::parameters | Parameters for the class sonyEviD100P |
lti::toUCam::parameters | FrameGrabber parameters class |
lti::uciDataReader::parameters | Parameters for the class uciDataReader |
lti::expandVector::parameters | Parameters for the class expandVector |
lti::studentDistribution::parameters | The parameters for the class studentDistribution |
lti::blueScreen::parameters | Parameters for the class blueScreen |
lti::bagging::parameters | Parameters for the class bagging |
lti::ioImage::parameters | Parameter class of the ioImage class |
lti::borderExtrema::parameters | Parameters for the class borderExtrema |
lti::microEnablePulnix::parameters | FrameGrabber parameters class |
lti::kernelFunctor< T >::parameters | Parameters for the class distanceFunctor |
lti::directedPerceptionPTU::parameters | The parameters for the class DirectedPerceptionPTU |
lti::borderSignature::parameters | Parameters for the class borderSignature |
lti::gHoughTransform::parameters | Parameters for the class houghTransform |
lti::backSubstitution< T >::parameters | Parameters for the class backSubstitution |
lti::quickPartialSort< T >::parameters | The parameters for the class quickPartialSort |
lti::fastSVD< T >::parameters | FastSVD parameter class |
lti::ioLTI::parameters | Parameter class of the ioLTI class |
lti::boundsFunctor< T >::parameters | Parameters for the class boundsFunctor |
lti::boundingBox< T >::parameters | Parameters for the class boundingBox |
lti::chiSquareFunctor::parameters | Parameters for the class chiSquareFunctor |
lti::ioBMP::parameters | Parameter class of the ioBMP class |
lti::choleskyDecomposition< T >::parameters | Parameters for the class choleskyDecomposition |
lti::fundamentalMatrixSolverLMS::parameters | Parameters for the class fundamentalMatrixSolverLMS |
lti::continuousRandomDistribution::parameters | Parameters of the random distribution |
lti::brightRGB::parameters | Parameters for the class brightRGB |
lti::serialVectorStats< T >::parameters | Parameters for the class serialVectorStats |
lti::serialStatsFunctor< T, U >::parameters | Parameters for the class meansFunctor |
lti::coordinateTransformation::parameters | ------------------------------------------------------------------ start of parameters The parameters for the class coordinateTransformation |
lti::hessianFunctor::parameters | The parameters for the class hessianFunctor |
lti::featureExtractor::parameters | Parameters for the class featureExtractor |
lti::scramble< T >::parameters | Parameters for the class scramble (empty) |
lti::cubicSpline< T >::parameters | Parameters for the class cubicSpline |
lti::locationSearchEvaluation::parameters | The parameters for the class locationSearchEvaluation |
lti::maximumFilter< T >::parameters | Parameters for the class maximumFilter |
lti::validator::parameters | Parameters for the class validator |
lti::calibrationBlobFeatures::parameters | Parameters for the class calibrationBlobFeatures |
lti::delaunayTriangulation< T >::parameters | Parameters for the class delaunayTriangulation |
lti::loweGradientFeature::parameters | The parameters for the class loweGradientFeature |
lti::generalEigenVectors< T >::parameters | EigenSystem parameter class |
lti::discreteRandomDistribution::parameters | Parameters of the random distribution |
lti::DistanceFromPixel::parameters | The parameters for the class DistanceFromPixel |
lti::poissonDistribution::parameters | Parameters class for the poisson distribution |
lti::colorModelSelector::parameters | Parameters for the class colorModelSelector |
lti::orientationFeature::parameters | Parameters for the class orientationFeature |
lti::similarityMatrix::parameters | Parameters for the class similarityMatrix |
lti::camshiftTracker::parameters | Parameters for the class camshiftTracker |
lti::histograming1D::parameters | Parameters for the class histograming1D |
lti::histogramRGBL::parameters | Parameters for the class histogramRGBL |
lti::eigenSystem< T >::parameters | EigenSystem parameter class |
lti::hmmTrellisDiagram::parameters | Parameters for the class hmmTrellisDiagram |
lti::jacobi< T >::parameters | EigenSystem parameter class |
lti::entropyFunctor< T >::parameters | Parameters for the class entropyFunctor |
lti::homography8DofEstimator::parameters | The parameters for the class homography8DofEstimator |
lti::equallySpacedSamplesInterpolator::parameters | Parameters for the class equallySpacedSamplesInterpolator |
lti::cannyEdges::parameters | Parameters for the class cannyEdges |
lti::homography9DofEstimator::parameters | The parameters for the class homography9DofEstimator |
lti::decompositionSolution< T >::parameters | DecompositionSolution parameter class |
lti::quickMedian< T >::parameters | The parameters for the class quickMedian |
lti::colorACASegmentation::parameters | The parameters for the class colorACASegmentation |
lti::qrSolution< T >::parameters | QrSolution parameter class |
lti::homographyEstimatorBase::parameters | The parameters for the class homographyEstimatorBase |
lti::euclideanSimilarity< T >::parameters | Parameters for the class similarityFunctor |
lti::cartesianToPolar< T >::parameters | Parameters for the class cartesianToPolar |
lti::chromaticityHistogram::parameters | Parameters for the class chromaticityHistogram |
lti::classificationStatistics::parameters | Parameters for the class classificationStatistics |
lti::fastEigenSystem< T >::parameters | EigenSystem parameter class |
lti::kullbackContrast::parameters | Parameters for the class kullbackContrast |
lti::sort2< T, U >::parameters | The parameters for the class sort |
lti::linearRegression< T >::parameters | Parameters for the class linearRegression |
lti::channelStatistics::parameters | Parameters for the class channelStatistics |
lti::fMatrixEstimator::parameters | The parameters for the class fMatrixEstimator |
lti::hmmOnlineClassifier::parameters | Parameters for the class hmmOnlineClassifier |
lti::chrominanceModelEstimator::parameters | The parameters for the class chrominanceModelEstimator |
lti::chrominanceMapMasking::parameters | The parameters for the class chrominanceMapMasking |
lti::radialKernel::parameters | Parameters for the class distanceFunctor |
lti::lvq::parameters | Parameters for the class classifier |
lti::gaussianDistribution::parameters | Parameters for gaussian distribution |
lti::chrominanceMapEstimator::parameters | Parameters for the class chrominanceModelEstimator |
lti::medianCut::parameters | Parameters for the class medianCut |
lti::whiteningSegmentation::parameters | Parameters for the class whiteningSegmentation |
lti::gaussianMixtureModel< T >::parameters | The parameters for the class gaussianMixtureModel |
lti::generalizedEigenSystem< T >::parameters | Parameters for the class generalizedEigenSystem |
lti::isotropicNormalization::parameters | The parameters for the class isotropicNormalization |
lti::fastGeneralizedEigenSystem< T >::parameters | Parameter class for fastGeneralizedEigenSystem |
lti::kalmanFilter::parameters | The parameters for the class kalmanFilter |
lti::loadImageList::parameters | Parameters for the class loadImageList |
lti::kalmanTracker::parameters | The parameters for the class kalmanTracker |
lti::kMColorQuantization::parameters | Parameters for the class kMColorQuantization |
lti::susanEdges::parameters | Parameter class for susanEdges |
lti::interpolator::parameters | Parameters for the class interpolator |
lti::kMeansSegmentation::parameters | Parameters for the class kMeansSegmentation |
lti::symmetricMatrixInversion< T >::parameters | Parameters for the class symmetricMatrixInversion |
lti::kNearestNeighFilter::parameters | Parameters for the class kNearestNeighFilter |
lti::kernelPCA::parameters | Parameters for the class principalComponents |
lti::computePalette::parameters | Parameters for the class computePalette |
lti::classifier::parameters | Parameters for the class classifier |
lti::labelAdjacencyMap::parameters | Parameters for the class labelAdjacencyMap |
lti::coilBackgroundSegmentation::parameters | Parameters for the class coilBackgroundSegmentation |
lti::linearMapperFunctor< Tin, Tout >::parameters | Parameters for the class linearMapperFunctor |
lti::activeShapeModel::parameters | Parameters for the class activeShapeModel |
lti::linearSatMapperFunctor< Tin, Tout >::parameters | Parameters for the class linearSatMapperFunctor |
lti::classicEdgeDetector::parameters | The parameters for the class classicEdgeDetector |
lti::mathFunction::parameters | Parameters for the class mathFunction |
lti::opponentColor::parameters | Parameters for the class opponentColor |
lti::colorEdgesGS::parameters | Parameters for the class colorEdgesGS |
lti::url::parameters | Parameters for the url-object |
lti::randomDistribution::parameters | Parameters of the random distribution |
lti::localMoments::parameters | The parameters for the class localMoments |
lti::lkmColorQuantization::parameters | Parameters for the class lkmColorQuantization |
lti::cyclicTridiagonalEquationSystem< T >::parameters | CyclicTridiagonalEquationSystem parameter class |
lti::polynomRoots::parameters | Parameters for the class polynomRoots |
lti::locationSelector::parameters | Parameters for the class locationSelector |
lti::qrDecomposition< T >::parameters | The parameters for the class qrDecomposition |
lti::colorNormalizationBase::parameters | Parameters for the class colorNormalizationBase |
lti::maskImage::parameters | Parameters for the class maskImage |
lti::manualCrispDecisionTree::parameters | Parameters for the class manualCrispDecisionTree |
lti::linearAlgebraFunctor::parameters | Parameters for the linear algebra functors |
lti::scalarFunctor< T >::parameters | Scalar value parameter needed in scalar functors |
lti::meanShiftSegmentation::parameters | Parameters for the class meanShiftSegmentation |
lti::colorQuantization::parameters | Parameters for the class colorQuantization |
lti::serialPCA< T >::parameters | Parameters for the class serialPCA |
lti::comprehensiveColourNormalization::parameters | Parameters for the class comprehensiveColourNormalization |
lti::meanshiftTracker::parameters | Parameters for the class meanshiftTracker |
lti::classifier::parametersOutOfRangeException | Exception thrown when a parameter is out of range |
lti::paretoFront | Pareto Front computation with PESA |
lti::paretoFrontTester | The 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::patternId | The ID of a class is determined with three attributes: |
lti::pdmGenerator | This class creates a pointDistributionModel (PDM) given a set of shapes of type pointDistributionModel::shape |
lti::plusLTakeAwayR | This class implements the plus l - take away r algorithm descripted in: P |
lti::pointDistributionModel | This class is the data structure for a Point Distribution Model (PDM) |
lti::kNNClassifier::pointInfo | Information about a feature point |
lti::pointSetNormalization | A parent class for normalizations of point sets |
lti::poissonDistribution | Poisson 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::polygonApproximation | Computes a polygon approximation for a given border point list |
lti::polygonPoints | Polygon Points of Integer Points |
lti::polynomialKernel | This class defines a polynomial kernel functor |
lti::polynomRoots | Find 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::probabilityMap | Probability Map based on 3D non-parametric (color) models |
lti::probabilityMap2D | Probability Map based on 2D non-parametric (color) models |
lti::probabilityMapBase | Base class for all probability map classes, e.g |
lti::processInfo | LTI-Lib process info class |
lti::processInfo::procStatus | System depended structure |
lti::progressInfo | Progress information interface |
lti::stdLayer::propagationFunctor | Parent 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::pyramidLocationSearch | Search for salient locations in the scale space of a channel |
lti::qmf | This class implements dyadic wavelet-transform as quadrature mirror filters |
lti::qmfEnergy | The qmfEnergy is a functor for extraction of texture features |
lti::qmfInverse | This 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::quadTreeSegmentation | Quad-Tree based color image segmentation method |
lti::quickCam | Class 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::radialKernel | This class defines a radial kernel functor |
lti::lvq::randInitFunctor | Random initialization |
lti::randomDistribution | Base random number class |
lti::ransacEstimator | This class estimates a transform using the Ransac algorithm |
lti::hsvHistogramViewer::ray | A 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::rbf | Class which implements RBF networks |
lti::readWriteLock | Lti read-write synchronisation class |
lti::realFFT | A class for FFT |
lti::realInvFFT | A class for inverse FFT |
lti::recognitionRateOfSubset | Computes the average recognition rate of a given subset of features from a data set |
lti::rectLocation | Small 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::regionGraphColorHarisDistance | Compute the weight between two color point nodes as the euclidean distance between both points |
lti::regionGraphColorMeanDistance | Compute 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::regionGraphScalarHarisDistance | Compute the weight between two scalar nodes as the absolute value of the difference |
lti::regionGraphScalarMeanDistance | Compute the weight between two scalar nodes as the absolute value of the difference |
lti::regionGrowing | This class is used to segmentate an image with a regular background |
lti::regionMerge | This 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::regionShapeFeatures | This functor computes descriptors for shapes, decomposing a binary mask as a sum of some basis functions |
lti::regionsPolygonizer | This 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::relativeThresholding | This class implements percentual Thresholding |
lti::rgbColor | An alias for the rgbPixel type |
lti::rgbPixel | Color pixel representation in RGB color space |
lti::rgbPixel::rgbPixelType | This 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::robustEstimator | A parent class for estimating a transform from sets of points in a robust manner |
lti::rotation | Rotation implements a rotation functor |
lti::runLengthCodec | Encodes a byte array to an array of hexadecimal digits or performs the corresponding decoding method, depending on the parameters |
lti::saliency | Base class for all saliency modifiers |
lti::sammonsMapping | Performs Sammon's Mapping |
lti::saveBMP | Functor to save a bitmap (BMP) file |
lti::saveImage | This class is used to save lti::image or lti::channel objects in files of one of the formats supported by the LTI-Lib |
lti::saveJPEG | Functor 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::saveLnc | Class to save lnc-files (ascii format to store feature vectors) |
lti::saveLTI | Functor to save a bitmap (LTI) file |
lti::savePNG | Functor 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::scaling | Scaling implements a functor to rescale an image using a real valued scaling factor |
lti::scene3D< T > | Tool for creating three dimensional scenes |
lti::scene3DViewer | View a scene3D object |
lti::schieleCrowley6DFeature | This 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::segmentation | Base class for all segmentation algorithms |
lti::segmentationEvaluation | Pareto evaluation of segmentation functors |
lti::selective2DConvolution | This modifier is used to convolve individual points of a given channel with a arbitrary kernel2D<float> (e.g |
lti::semaphore | Lti semaphore class for inter-thread (not inter-process!) synchronisation |
lti::sepKernel< T > | Separable Kernel |
lti::sequence< T > | Sequence container class |
lti::sequentialBackwardSearch | This class implements the sequential backward search algorithm for feature selection |
lti::sequentialForwardSearch | This class implements the sequential forward search algorithm for feature selection |
lti::serial | This 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::serviceHandler | This is an abstract base class for handling a kind of data service |
lti::sffs | Implemantation of the sequential floating forward search algorithm to select the best features from a data set |
lti::shapeFeatureExtractor | Base class for all clases which extract features from shapes displayed with pointLists |
lti::shClassifier | Implements a sparse histogram-based classifier, such as the one described in B |
lti::shiftInvariance | This functor takes a vector, which is supposed to be periodic, and generates a second "normalized" shifted one |
lti::stdLayer::sigmoidActFunctor | Sigmoid activation function |
lti::MLP::sigmoidFunctor | Sigmoid activation function |
lti::sigmoidKernel | This class defines a "sigmoid" kernel functor |
lti::MLP::signFunctor | Sign 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::similarityMatrix | Given 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_node | Type for a single linked list |
lti::hiddenMarkovModel::singleDensity | This class represents a single multivariate (ie multidimensional ) score density function within a state of a hidden markov model |
lti::linearAlgebraFunctor::singularMatrixException | Singular matrix exception |
lti::singularValueDecomp< T > | Singular Value Decomposition |
lti::skeleton | Homotopy preserving Skeleton |
lti::skinASM | This is an alignment strategy for activeShapeModels (ASM), that works on a gradient channel and a skin probability channel, to trace skin colored objects |
lti::skinProbabilityMap | Creates a skin probability map |
lti::localColorFeature::sliceMask | Simple structure used to hold a mask and the correspoinding io-points of the circle |
lti::smallObjectList< T > | SmallObjectList template class |
lti::snake | Snake 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::SOFM | This is the base class for all Self Organizing Feature Maps |
lti::SOFM2D | This is a Self-Organizing Feature Map with a 2-D grid of neurons |
lti::SOFM2DVisualizer | This class provides some possibilites to visualize the given SOFM |
lti::sonyEviD100P | Access 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 >::sortHelper | Helper class for sorting |
lti::sparseHistogram | Simple sparse multidimensional histogram |
lti::sparseMatrix< T > | SparseMatrix container class |
lti::splitImage | Parent for all classes that split image into differen color spaces components (color channels) |
lti::splitImageFactory | This class defines a factory for functors that split color images in their color components |
lti::splitImageToCIELuv | Split image in its Luv channels |
lti::splitImageToGSC | Split image in its c1, c2 and c3 components, as described in T |
lti::splitImageToGSL | Split image in its l1, l2 and l3 components, as described in T |
lti::splitImageToHLS | Split image in its Hue - Luminance - Saturation channels |
lti::splitImageToHSI | Split image in its Hue - Saturation - Intensity channels |
lti::splitImageToHSV | Split image in its Hue - Saturation - Value channels |
lti::splitImageToOCP | Split image in an oponent colour system |
lti::splitImageToRGB | Split image in its Red - Green - Blue channels |
lti::splitImageTorgI | Split image in its chromaticity channels |
lti::splitImageToxyY | Split image in its xyY norm chromaticity channels |
lti::splitImageToXYZ | Split image in its XYZ norm channels |
lti::splitImageToYCbCr | Computes the YCbCr values from a given RGB color representation (rgbPixel) |
lti::splitImageToYIQ | Split image in its Luminance Inphase Quadrature channels |
lti::splitImageToYPbPr | Computes the YPbPr values from a given RGB color representation (rgbPixel) |
lti::splitImageToYUV | Computes 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::stackElement | Type for each element of the stack |
lti::statisticsFunctor | This is the base class for all kinds of nice statistics functors |
lti::status | Base class for all lti objects that can have a status text |
lti::stdLayer | This abstract class implements a standard neural network layer |
lti::strassenMultiplication< T > | Implementation for the addtion forms: |
lti::streamProgressInfo | Progress Information to stream |
lti::studentDistribution | The Student t-test compares the means of two normally distributed samples of sizes n1 and n2, assuming that their unknown variances are equal |
lti::supervisedInstanceClassifier | Abstract class, parent of all supervised instance classifiers |
lti::supervisedInstanceClassifierFactory | This class defines a factory for classifiers |
lti::supervisedSequenceClassifier | Abstract class, parent of all supervised classifiers for sequences |
lti::susan | A class for SUSAN image Processing |
lti::susanCorners | Corner finder with the Susan low level image processing algorithm |
lti::susanDenoise | The susan denoiser enhances pictures by removing the noise from any colour channel |
lti::susanEdges | The Susan Edge Detector |
lti::susan::susanError | Susan error exception |
lti::svm | Implements 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::tap9Symmetric | 9 tap symmetric filter kernel |
lti::tbox< T, S > | Class to describe a 3D box aligned with the coordinate system |
lti::temporalTemplate | This 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::thread | Lti thread class |
lti::thresholding | Threshold segmentation of a single channel (monochrom) image or a contour |
lti::thresholdSegmentation | Threshold segmentation of a single channel (monochrom) image or a contour |
lti::timer | The 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::TmeanProbability | Type combining the region with its mean color, probability and relation to background and object |
lti::toUCam | Philips 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::trainFunctor | Base class of training functors for the lvq networks |
lti::stdLayer::trainFunctor | Training functor |
lti::transform | A base class for integral transformations |
lti::transformEstimator | A parent class for estimating a transform from sets of points |
lti::transformEstimatorFactory | This class defines a factory for transform estimator functors |
lti::translationScaleEstimator | This 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 >::triangle | Triangle is the base for all other polygons |
lti::triangularKernel1D< T > | One-dimensional filter kernel |
lti::triangularMatrixType | This 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::uciDataReader | Reads 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::uciDataWriter | Writes 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::uniformDistribution | Uniform distributed random number class |
lti::crispDecisionTree::univariateCrispDecisionFunction | This class implements the most common decision function: Each node has a real-valued threshold in one dimension only |
lti::unsupervisedClassifier | Abstract class, parent of all unsupervised classifiers |
lti::upsampling | Upsampling is the complementary functor to lti::downsampling |
lti::url | Class for retrieving documents identified by an URL |
lti::url::urlFields | This class is used to split a URL into its separate fields |
lti::usePalette | Use color or gray-valued palette |
lti::validator | Checks the validity of a matrix or vector with float or double elements |
lti::variablySpacedSamplesInterpolator | This 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::vec2d | Position/direction vector type |
lti::vector< T > | Vector container class |
lti::viewer | Use objects of this class to display your data in a window |
lti::viewerBase | Abstract class parent for all viewer objects in the LTI-Lib |
lti::viewerBase3D | This is the base class for all viewer classes which show 3D data |
lti::viewerFunctor | This viewerFunctor has as task to prepare an image, that will be visualized in the lti::viewer |
lti::watershedSegmentation | Watershed segmentation of a channel8 |
lti::weightedGraph< P, D, W > | Weighted Graph container class |
lti::whiteningSegmentation | The whitening segmentation is an extention of the k-Means based segmentation (see lti::kMeansSegmentation) |