IRIS-XT

What is IRIS-XT?

IRIS-XT is the component of the IRIS vision system which is responsible for basic image processing tasks as well as 2D machine vision functions like line following and object detection, IRIS-XT uses the classes defined by IRIS Foundation and also defines some data structures of its own. IRIS-XT is the second oldest component of the entire system and thus is reliable and easy to use.

Detailed documentation is not the aim of this section, which provides a general overview of IRIS-XT's structure, so as to give the potential reuser a better inital understanding of the system architecture.

A rough structural description

IRIS-XT resides in the namespace Comrade::IrisXT, so to use it, you'll either have to refer to its data types and functions in a fully qualified fashion, or bring in the whole thing with the using directive.

The classes currently implemented in the IRIS-XT are as follows:

• KernelMatrix: This structure holds the values of the kernel during the convolution of an image with a mask. It can be of any size, and can be generated automatically in some situations like edge detection and Gaussian masking by setting appropriate parameters to desired values.

• KernelOperator: This class is responsible for the actual convolution process between a HSL image and a KernelMatrix mask. It also perform greyscale convolution of a RGB image.

• KernelGenerator: This class can generate special standard masks which are used frequently enough to warrant automated generation. Most of these masks are used different edge detectors. They are:
  
  

  1. Roberts' cross operator
  2. Sobel's operator
  3. Prewitt's operator
  4. Isotropic operator
  5. Laplacian operator (zero crossing operator)
  
  Other than that, there is the Gaussian kernel which is used for the Canny edge detector.

• EdgeDetectorManager: So as to ease programming, this class shields the programmer from explicitly defining kernels for edge detection. The kernels are generated internally by calling the appropriate function and passing the specified arguments.

• CA_EdgeDetector: This class implements a very simple, but useful edge detector of my own design. It is based on the principles of Cellular Automata, and it is certainly faster than convolution, though the results show some noise. But it may be adequate for most purposes. See the Discussions section for more details.

• AlgorithmManager: This class encapsulates all functions which cannot be achieved using kernel convolution. There are several functions defined here, and all are useful in their own right. They are:
  
  

  1. Dilation
  2. Erosion
  3. Conversion to greyscale image
  4. Conversion to negative image
  5. Independent RGB channel adjustment
  6. Unsharp masking
  7. Range compression
  8. Contrast stretching
  9. Histogram equalisation
  
  In addition, there are some internal functions which perform calculations on images, but these are not meant to be accessed by the programmer.

• StraightLineDetector: This class performs the Hough Transform on an image already processed by an edge detector and determines possible straight lines. The result is an angle with respect to some reference axis. This is currently under development, i.e., not tested thoroughly as yet. Actually, another function regression() is also capable of finding straight lines but is more susceptible to noise, though faster.

• BasicShapeDetector: This class, together with the StraightLineDetector class, forms the Hough Transform Engine. This class performs the Generalised Hough Transform on an image, and will detect arbitrary shapes even in the presence of noise and/or occlusions.

• ShapeSampler: This class is used to sample edge-detected shapes, i.e., build a table of distances between some point and the (potential) perimeter of a shape in increments specified by the programmer. This gives a shape table which may be correlated with some stored shape table or may be used as a prototype shape table for future matching by direct comparison. This class is also used by the Hough Transform Engine.

• SequenceAnalyser: This class is used to correlate shape tables to provide a measure of the degree of correlation between them. The presence of noise and false terminations is accomodated for by providing a cumulative error tolerance model. This provides an alternative to the Hough Transform Engine, but more work is required to increase the robustness of the method used.

Besides these, there is an experimental skeletoniser algorithm which awaits further development. Also note that most of the functions implemented in IRIS-XT can be applied to any rectangular region within an image, instead of the entire image. This provides opportunities for optimisation.

Known issues

• Canny edge detector does not detect edges in the expected manner for different values of the smoothing constant sigma.

• Have not decided a proper normalisation method for a shape table in the presence of noise, Need to decide upon a proper scale-independent correlation function.

• In the sampling algorithm, it may be possible for the radial line to 'miss' a perimeter pixel and continue increasing falsely. Must either dilate before sampling, or incorporate Bresenham's algorithm.