Image Component Library (ICL)
Fundamental Data Type Definitions


typedef Ipp64f icl::icl64f
 64Bit floating point type for the ICL
typedef Ipp32f icl::icl32f
 32Bit floating point type for the ICL
typedef Ipp32s icl::icl32s
 32bit signed integer type for the ICL
typedef Ipp16s icl::icl16s
 16bit signed integer type for the ICL (range [-32767, 32768 ])
typedef Ipp8u icl::icl8u
 8Bit unsigned integer type for the ICL
typedef uint32_t icl::icl32u
 32bit unsigned integer type for the ICL
typedef uint16_t icl::icl16u
 16bit unsigned integer type for the ICL
typedef int64_t icl::icl64s
 64bit signed integer type for the ICL
typedef uint64_t icl::icl64u
 64bit unsigned integer type for the ICL
typedef std::complex< icl32f > icl::icl32c
 float comples type
typedef std::complex< icl64f > icl::icl64c
 float comples type

Detailed Description


The ICLUtils package contains C++ support functions and classes that do no depend on the ICL's image classes.

The packe can be grouped into the following modules:

  1. Time and Timer Support Classes and Functions
  2. Special Exceptions
  3. Support Functions for Multi-Threading
  4. Random Number Generation fuctions and classes
  5. General purpose Utiltiy Classes and Functions
  6. Programm Argument Evaluation Functions
  7. XML Pasing and Creation Environment
  8. String Manipuation Functions
  9. ICL's Function Class and Creation Functions

Support classes

The ICLUtils package provides some of ICL's most basic support classes and interfaces:

String manipulation functions

String manipulation is always a bit complicated in C++, even though C++'s <string>-header provides the powerful std::string-class. The header file ICLUtils/StringUtils.h provides some additional utility functions and function-template that facilitate string manipulation significantly:

See also:
String Manipuation Functions

ProgArg evaluation environment

The progam argument evaluation environment can ca used to handle arguments, that are given to your programm in the command line. It consists essentially of tree main functions:

See also:
Programm Argument Evaluation Functions

Fixed matrices

ICL's icl::FixedMatrix-template class is a convenient and powerful tool for high-level object-oriented fixed-size matrix calculations. It provides a large set of basic functions and operators. The additional header ICLUtils/FixedMatrixUtils.h provides further high-level matrix-algebra-related functions like:

The dimensions of a FixedMatrix instance is given using template parameters, which allows us to use a fixed-size-array for its internal data storage, which significantly increases processing speed. However, if the dimensions of a matrix cannot be determined at compilation time ICL's dynamic matrix class must be used.

Dynamic Matrices

ICL's icl::DynMatrix-template-class is similar to the fixed-size one, except, it uses dynamic memory for it's data storage. Furthermore, DynMatrix instances can be created as shallow wrappers around externally managed data. The extra-header ICLUtils/DynMatrixUtils.h contains a much larger set of optionally Intel IPP and Intel MKL accelerated matrix functions.

See also:
Linear algebra classes and functions

XML Configuration Files

The icl::ConfigFile class is a powerful tool for the creation of configurable applications. Configuration files use the XML-format, which is natively parsed and created using ICL's own XML-parser. We decided to provide an own parser, in order to avoid an additional large dependency. The ConfigFile class provides convenient access functions that allow to obtain or event to set entries of the hierarchically organized xml-files.
Moreover, the ICLQt package provides a GUI-component that can easily be embedded into complex GUIs in order to provide an interface manipulate configuration file entries at run-time.

See also:
XML Pasing and Creation Environment

Timing and threading utilities

Dynamic applications ofter make use of several threads. In particular, Qt-GUI-based applications normally have a dedicated working thread in addition to the applications main-thread which processes Qt's GUI-event-loop. To facilitate handling of threaded applications, the ICLUtils package contains classes as icl::Thread and icl::Mutex which provide an object-oriented interface for the underlying posix-thread (using libptread) layer. Timing and benchmarking tools as e.g. icl::Time or icl::StackTimer complete this function-set.

See also:
Support Functions for Multi-Threading
Time and Timer Support Classes and Functions

Function Class Creation

General Information

Usage Example

The following example was taken from ICL/ICLUtils/examples/function-test.cpp. It demonstrates most used cases of ICL's Function class template.

#include <ICLUtils/Function.h>
#include <iostream>
#include <algorithm>
#include <vector>

// first, we need some global functions and class definitions
// whose methods can be wrapped later on.

using namespace icl::utils;
void global_foo(){
  std::cout << "void global_foo()" << std::endl;
int global_foo2(){
  std::cout << "int global_foo() returning 5" << std::endl;
  return 5;

int global_add(int a, int b) { return a+b; }

struct Foo{
  int add(int a, int b){
    std::cout << "Foo.add(" << a << "," << b << ") = " << a+b << std::endl;
    return a+b;
  int operator()(int a, int b){
    std::cout << "Foo(" << a << "," << b << ") = " << a+b << std::endl;
    return a+b;
  static void show_int(int i){
    std::cout << i << std::endl; 

int main(){
  // simple parameterless global function
  Function<void> gfoo(global_foo); 

  // global function that returns an int
  Function<int> gfoo2(global_foo2); 
  std::cout << gfoo2() << std::endl;
  // Implicit cast from function with return value to function without return value
  Function<void> gfoo3 = function(global_foo2); 

  // Global function with parameters
  // identical to function(global_add)(4,5)
  Function<int,int,int> gadd(global_add); 
  std::cout << "global_add(4,5)=" << gadd(4,5) << std::endl;

  // Global function with parameters (ignoring the result of the function)
  // Functions with non-void return type can always be casted into another
  // Function type with return type (the return value is simply ignored then)
  Function<void,int,int> gadd_void = function(global_add); gadd_void(4,5);

  // create an std::vector
  std::vector<int> v;
  // void-Member function with one parameter
  // preserve type-correctness (argument is not int, but const int&)
  Function<void,const int&> vpush = function(v,&std::vector<int>::push_back);
  vpush(1);  vpush(2);  vpush(3);

  // access elements with this function
  Function<int&,unsigned int> vat = function(v,&std::vector<int>::at);
  std::cout << "elem 0: " << vat(0) << std::endl;
  std::cout << "elem 1: " << vat(1) << std::endl;
  std::cout << "elem 2: " << vat(2) << std::endl;

  // create an instance of the foo class
  Foo f;
  // creating a list of functions of same type
  std::vector<Function<int,int,int> > list;
  list.push_back(function(f,&Foo::add)); // member function
  list.push_back(function(f,SelectFunctor<int,int,int>())); // a functor
  list.push_back(global_add);  // a global function
  // Finally, we are also able to implement the FunctionImpl-interface
  // here, we have to implement the corresponding constructor 
  // (which must const!!!)
  struct Impl : FunctionImpl<int,int,int>{
    virtual int operator()(int a, int b) const{ 
      std::cout << "custom impl:operator()(a,b) = " << a+b << std::endl;
      return a+b;
  // list.push_back(function(new Impl)); 
  // would also be possible, but implicit cast is possible
  list.push_back(new Impl);
  // clear the vector of ints also by using a Function-instance:

  // create a function that wraps the index operator
  Function<int&,unsigned int> vidxop = function(v,&std::vector<int>::operator[]);

  // push the results of the function in the vector
  for(unsigned int i=0;i<list.size();++i){

  // create a function for the vector size
  Function<size_t> vsize = function(v,&std::vector<int>::size);
  // show the result of the vector-size function
  std::cout << vsize() << std::endl;
  for(unsigned int i=0;i<vsize();++i){
    std::cout << "v[" << i << "] = " << vidxop(i) << std::endl;
  // or use a function and std::for_each to print the results
See also:
ICL's Function Class and Creation Functions

Typedef Documentation

typedef Ipp16s icl::icl16s

16bit signed integer type for the ICL (range [-32767, 32768 ])

typedef uint16_t icl::icl16u

16bit unsigned integer type for the ICL

typedef std::complex<icl32f> icl::icl32c

float comples type

typedef Ipp32f icl::icl32f

32Bit floating point type for the ICL

typedef Ipp32s icl::icl32s

32bit signed integer type for the ICL

typedef uint32_t icl::icl32u

32bit unsigned integer type for the ICL

typedef std::complex<icl64f> icl::icl64c

float comples type

typedef Ipp64f icl::icl64f

64Bit floating point type for the ICL

typedef int64_t icl::icl64s

64bit signed integer type for the ICL

typedef uint64_t icl::icl64u

64bit unsigned integer type for the ICL

typedef Ipp8u icl::icl8u

8Bit unsigned integer type for the ICL

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines