Image Component Library (ICL)
Namespaces | Classes | Typedefs
icl Namespace Reference

undocument this line if you encounter any issues! More...




class  FoldMap
 discretized paper space representing folds More...
class  InverseUndistortionProcessor
 Utility class that performs gradient-descent based inverse undistortion mapping. More...


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

Detailed Description

undocument this line if you encounter any issues!

all ICLQuick functions are placed here

The icl namespace.

icl namespace

The ICL-namespace.

This namespace is dedicated for ICLCore- and all additional Computer-Vision packages, that are based on the ICLCore classes.

\defgroup G_RD Region Detection Package
\defgroup G_CBS Color Blob Searcher API (template based)
\defgroup G_PT Position Tracker template class
\defgroup G_UTILS Utility classes and Functions
The ICLCV package contains functions and classes for region and blob detection and
for tracking. However, the most common component is the icl::RegionDetector class,
which performs a parameterized connected component analysis on images. Here are some sample
application screenshots:

\image html region-inspector.png "icl-region-inspector GUI"

\section BLOB_DEF Blobs and Regions
At first, we have to define the terms "Blob" and "Region":

A "Region" is a set of connected pixels. The set of pixels belonging to a single
Region has to fulfill a certain criterion of homogeneity (e.g. "all pixels"
have exactly the same value"). The term of "connection" must also be defined
more precisely in order to avoid misunderstandings. A pixel is connected to all pixels in
it's neighborhood, which in turn is given by the 4 pixels (to the left, to the
right, above and below) next to the reference pixel.
The also very common neighborhood that contains the 8 nearest neighbours is currently
not supported. E.g. a connected component analysis yields a list of Regions.\n\n
A Blob is a more general local spot in an image. Blobs don't have to be connected

\section SEC_DETECTION_VS_TRACKING Detection vs. Tracking

We differentiate explicitly between <em>detection</em> and <em>tracking</em>.
When regions or blobs are <em>detected</em> in an image, no prior knowledge for the supposed
image location is used, i.e. the region/blob is detected in the whole image.\n
In contrast, blob <em>tracking</em> of blob means, that blobs are tracked in general
from one time step to another, i.e the former blob location is used as prior guess
for it's location in the current frame (tracking over time).

\section BLOB_APPROACHES Different Blob Detection Approaches

The ICLCV package provides some different blob detection and tracking approaches,
that are introduced shorty in the following section. For a more detailed insight
look at the corresponding class descriptions.

\ref G_CBS \n
The Color Blob Searcher API is a template based framework which provides a
mechanism for a color based blob detection. In this approach each blob is
determined by a special color, so blobs with identical colors are mixed together.
Main class is the icl::ColorBlobSearcher template.

\ref G_RD \n
The icl::RegionDetector performs a connected component analysis on images.
Regions that can be found must be connected and
must show identical gray values (color images can not be processed yet). Commonly the
input image of the RegionDetector's <em>detect(...)-method</em> is a kind of feature
map that shows only a small number of different gray values (see the class
documentation for more detail). The set of detected image regions can be restricted by:
(i) a minimal and maximal gray value and (ii) a minimal and maxmial pixel count
<b>Note:</b> The algorithm is highly speed-optimized, by using a special kind of
self developed memory handling, which avoids memory allocation and deallocation at
runtime if possible. Given large images with O(pixel count) regions (e.g. ordinary
gray images instead of a feature map) the algorithm may need more physical memory than
available. A very common pre-processing function may be <b>ICLFilter/LUT::reduceBits(..)</b>.
In section \ref REGION_DETECTOR_EXAMPLE an example is presented.

\ref G_PT \n
These approaches above all perform Blob or region detection. The icl::PositionTracker or
it's generalized version icl::VectorTracker can be used to tracking the resulting regions
or blobs through time.

\ref G_UTILS \n
In this group some additional support classes and functions are provided

\section CSS_CORNERS The Curvature Scale Space

The curvature scale space can be used to extract 2D geometry models from regions.
<b>Erik:</b> Please add some information here!

\image html css-demo.jpg "icl-corner-detection-css-demo GUI"

\section REGION_DETECTOR_EXAMPLE Region Detection Example
<table border=0><tr><td>

#include <ICLQt/Common.h> #include <ICLCV/RegionDetector.h> #include <ICLFilter/ColorDistanceOp.h>

icl::qt::GUI gui; GenericGrabber grabber; RegionDetector rd(100,1E9,255,255); ColorDistanceOp cd(Color(0,120,240),100);

void mouse(const MouseEvent &e){ if(e.isLeft()){ cd.setReferenceColor(e.getColor()); } }

void init(){ grabber.init(pa("-i")); gui << Draw().handle("image") << Show(); gui["image"].install(mouse); }

void run(){ DrawHandle draw = gui["image"]; const core::ImgBase *I = grabber.grab();

draw = I;

std::vector<ImageRegion> rs = rd.detect(cd.apply(I)); for(size_t i=0;i<rs.size();++i){ draw->linestrip(rs[i].getBoundary()); } draw->render(); } int main(int n,char **v){ return ICLApp(n,v,"-input|-i(2)",init,run).exec(); }

</td><td valign=top>
\image html icl-online-region-detection-demo-screenshot.png "icl-online-region-detection-demo screenshot"

Typedef Documentation

◆ icl16s

typedef Ipp16s icl::icl16s

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

◆ icl16u

typedef uint16_t icl::icl16u

16bit unsigned integer type for the ICL

◆ icl32c

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

float comples type

◆ icl32f

typedef Ipp32f icl::icl32f

32Bit floating point type for the ICL

◆ icl32s

typedef Ipp32s icl::icl32s

32bit signed integer type for the ICL

◆ icl32u

typedef uint32_t icl::icl32u

32bit unsigned integer type for the ICL

◆ icl64c

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

float comples type

◆ icl64f

typedef Ipp64f icl::icl64f

64Bit floating point type for the ICL

◆ icl64s

typedef int64_t icl::icl64s

64bit signed integer type for the ICL

◆ icl64u

typedef uint64_t icl::icl64u

64bit unsigned integer type for the ICL

◆ icl8s

typedef int8_t icl::icl8s

8bit signed integer

◆ icl8u

typedef Ipp8u icl::icl8u

8Bit unsigned integer type for the ICL