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

Conceptual Class Hierarchy in the LTI-Lib

We can group the functionality of the LTI-Lib into several categories:


Data Structures

The LTI-Lib provides data structures necessary to store different kinds of data required in computer vision and mathematical applications.

There are different levels of data structures

Basic Types

Due to the fact that the C++ standard does not define the exact size of the internal types, we need to specify some basic types, which a standardized size, independent of the system or processor where you compile the library.

These types are:

Geometric Primitives

Typical geometric elements in image processing application are implemented in the LTI-Lib. These are

Pixel Primitives

With the LTI-Lib you can manipulate channels of images extracted from different color spaces. The acquisition and display of color images is however always done in the RGB color space. Two types are provided to work in this space:

More information on extracting different color channels from the pixels or merging them into a color image can be found in the functors lti::splitImage and lti::mergeImage.

Many colors are defined as constant instances of lti::rgbPixel. Always defined are the values lti::Black, lti::White, lti::Red, lti::Green, lti::Blue, lti::Cyan, lti::Magenta and lti::Yellow. Many other definitions can be found in the file "ltiColors.h".

Aggregate Types

Matrices and Vectors

There are many aggregate types in the LTI-Lib, but two of them are very important:

You can cast between matrices (or vectors) of different types using the castFrom() methods.

Other vector and matrices types exist, to solve specific storage problems:

Channels and Images

The representation of images and channels are classes that inherit from lti::matrix. This means, in the LTI-Lib the images and channels are matrices of special types:

These three classes are widely used in all image processing algorithms of the LTI-Lib. For some special cases there is also a lti::channel32, that inherits from lti::matrix<int>.

You can cast between the different channels (gray valued images) using the castFrom() methods.

Filter kernels

The filter kernels are small vector or matrix similar types allowing an access with integer indices (not only positive values, but also negative ones).

Contours, Polygons and Regions

The image representation in form of matrices is not appropriate for all possible applications. Representations for contours and regions are also necessary. The types used in the LTI-Lib are:

Four classes inherit from the list of integer points:

You can cast between the last classes using the respective castFrom() methods.

Another important and more complex representations for shapes and their variations are the point distribution models ( lti::pointDistributionModel ). They can be constructed using lti::pdmGenerator.

Other aggregate types

Other aggregate types are:


Global Functions and Constants

There are several global functions necessary to extend the old C-typed math functions. Many of them are defined for several types, so that you do not need to explicitely cast. The most usual ones are:

Several geometry related global functions compute among other things the intersection between lines and the minimal distances between points and lines:

Usual constants are

Also global are the functions to read and write into lti::ioHandler objects. These functions are lti::read and lti::write

The global function lti::passiveWait is a wrapper function for the system dependent functions usleep and Sleep.


Functor

The most algorithms to process and analyze images or matrices are implemented as functors (see also Functors, parameters and states).

We have following functor categories:

Mathematical Operations

Following groups of mathematical functors exist in the LTI-Lib:

Linear Algebra

Many other basic linear algebra functions are directly implemented in the matrix classes. You can multiply, add, transpose, etc. vector and matrices. The dot product between two vectors of the same type is also build in. If you need the dot product of two vectors of different types you can use the lti::scalarProduct functor.

If you have compiled the LTI-lib with CLAPACK support enabled, there are some more linear algebra functors available:

Statistics

Random numbers

There are several random number generators that follow different discrete or continuous probability distributions:

Discrete random distributions:

Continuous random distributions:

With lti::noise you can add noise with a given distribution to matrices or vectors

Sorting

Interpolation

The base class of all interpolators is lti::interpolator.

Two basic classes of interpolation are distinguished for equal and variable distances between tabulated points, respectively:

These have the following subclasses:

Other Mathematical Functors

Image Processing

There are many different algorithms for image processing in the LTI-Lib:

Color Spaces

In the LTI-Lib there are only RGB images, but you can split it into the channels of different color spaces. You can also take three channels in a specific color space and merge them into a lti::image.

The classes to split a color image inherit from lti::splitImage and to merge channels you can use functors derived from lti::mergeImage. You can create your own linear color spaces transformations with lti::linearMixer.

The color spaces currently supported are:

Other functors for color analysis:

Color Quantization and Related Topics

An usual condition to many algorithms is to reduce the number of colors used in the color images.

This other functors are also useful:

Color and Intensity Analysis Techniques

To eliminate the influences of the illumination you can use functors derived from the class lti::colorNormalizationBase:

You can create statistical color models for one or more images in form of 3D histograms with lti::colorModelEstimator. You can employ these models to decide if a pixel belongs to the class it describes ( lti::probabilityMap ). The functor lti::colorModelSelector decides using a Maximum Likelihood approach which model in a set describes more appropriately the colors found in an image region.

Other functors for color analysis:

Subpixel interpolation

You can interpolate the values between pixels or elements in a vector using lti::scalarValuedInterpolation instances:

These classes are derived from lti::interpolator. See Interpolation

Mask Operations

Typical boolean and arithmetical operations to manipulate binary masks (images with only two values) can be found in the classes derived from lti::maskFunctor. The usual ones are:

Other usual operations with this kind of masks are Morphological Operators.

Edge and Corner Detectors

The edge detectors in the LTI-Lib inherit from lti::edgeDetector. You can use the lti::edgeDetectorFactory to create instances of all edge detectors existent in the LTI-Lib:

All corner detectors inherit from lti::cornerDetector. You can use the lti::cornerDetectorFactory to create instances of all corner detectors existent in the LTI-Lib:

Points, Contours and Shape Manipulation

Some basic geometrical operations are provided by the types described in Contours, Polygons and Regions. For example, you can get the convex hull of a set of points, approximate a contour with a polygon or get the boundary of an area or the area points enclosed by a contour using the casting methods of the from lti::tpointList<T> inherited classes.

Segmentation and Localization

Segmentation algorithms found in the LTI-Lib are (see also Segmentation Overview):

Other tools related with segmentation tasks are:

The functor lti::objectsFromMask deserves special attention. Usually the segmentation algorithms produce a the end a "labeled" mask, that contains an assignment for each pixel in an image to a specific object. This functor allows you to extract from this mask all found objects in a very efficient way. If this functor is too slow for your needs, and you do not require so much information as it provides, you can also try lti::fastRelabeling. It cannot detect which regions are within others, but this kind of information is not always required.

Algorithms used in the localization of specific image regions:

Saliency functors are used to detect parts of an image that are perceptually interesting:

Tracking and Optical Flow

Several mechanisms to track objects in images are provided in the LTI-Lib:

Optical flow functors:

Filters and Transformations

Classical filter operators are:

Image Transformations:

Two edge preserving filters are implemented:

Morphological Operators

Some classical and some unconventional morphological operations are already implemented:

Image Enhancement

Feature Extraction

With feature extraction functors are meant objects that extract some descriptors from images or shapes.

Color feature extractors:

Texture feature extractors:

Shape feature extractors:

Most functors listed above compute a descriptor for the whole image. This kind of descriptors are usually known as "global descriptors". There are other kinds of them to describe only small regions of an image. To extract these "local features" you usually need to compute first interesting locations. You can achieve this with lti::axLocalRegions (see also lti::locationSelector). Following functors can be used to extract the local features:

Feature Processing

3D Reconstruction

Input and Output

Reading and Writing Image Files

If you need for some reason to limit the file format you want to read or write to just one, you can use:

For the last two file formats there are two implementations that can be used with the LTI-Lib. We recommend the use of the JPEG-Lib and PNG-Lib implementations, which are part of the LTI-Lib. The required libraries are usually installed in all Linux distributions. It is faster, more robust and stable against incorrect files, and they are open source too.

The second implementation is NOT part of the LTI-Lib due to License problems. It is based on Mianos' code (Colosseum Builders C++ Image Library) and used per default in the Windows version of the LTI-Lib. You can get them as extra functors from the download pages and you can use them only if you agree with their conditions of use.

Reading and Writing Features

Some tests require to save and load files containing tons of feature vectors. This way you can separate the process of feature extraction from the training and test. At this time following functors are provided:

Getting Images from Frame Grabbers

A few functors to get images from frame grabbers are already implemented in the LTI-Lib. They all inherit from lti::frameGrabber.

Remember to "activate" your frame grabbers in the ltilib/src/io/ltiHardwareConfig.h file or to define the appropriate preprocessor macros while compiling!

Coding

Coding and Decoding functors between different formats inherit from lti::dataTransformer, (for example lti::asciiHexCodec or lti::runLengthCodec).

Other Input and Output Objects

If you need to read/write Standard Template Library (STL) containers include the header "ltiSTLIoInterface.h". It includes read and write methods for the following data structures:

These methods only work if the types T,U implement the operator=().


Classifiers

Classifiers are used in pattern recognition applications. They can be usually be trained with some training data, and later they can be used to test some learned properties, for example, to which class could belong a given point. A detailed description for these objects can be found in How to use the Classifiers..

Supervised Classifiers

Unsupervised Classifiers

Classification Tools


Visualization and Drawing Tools

Drawing Tools

Visualization of Classification and Statistical Data

Other tools used for visualization

Viewers

Operating System and Hardware related classes


Other Objects


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