llrfclass(3)

LIBRARY ROUTINE
llrfclass - Classify an image using the Localized Receptive Field classifier.

LIBRARY CALL
#include "vinclude.h"
int
llrfclass (image, cc_img, var_img, wt_img, class_img, border)
struct  xvimage  *image,       /* input image */
                 *cc_img,      /* cluster center image */
                 *var_img,     /* cluster variance image */
                 *wt_img,      /* lrftrain weight image */
                 **class_img;  /* output classified image */
int border;

INPUT

image
    the input image to be classified.

cc_img
    the cluster center image from training phase.

var_img
    the cluster variance image from training phase.

wt_img
    the resulting weight image from training phase.

border
    the border width in pixels of the input image.

OUTPUT

class_img
    the resulting classified image.

This routine was written with the help of and ideas from Dr. Don Hush, University of New Mexico, Dept. of EECE.

MODIFICATIONS

DESCRIPTION
lrfclass classifies an image using the Localized Receptive Field classifier (LRF). The Localized Receptive Field (LRF) is based on a single layer of self-organizing, "localized receptive field" units, followed by a single layer perceptron. The single layer of perceptron units use the LMS or Adaline learning rule to adjust the weights. The weights are adjusted or "trained" using the companion program, "lrftrain". After training the weights, using the "lrftrain" program, a number of similar images may be quickly classified with this program based on the training data set.

LRF network theory

The basic network model of the LRF consists of a two layer topology. The first layer of "receptive field" nodes are trained using a clustering algorithm, such as K-means, or some other algorithm which can determine the receptive field centers. Each node in the first layer computes a receptive field response function, which should approach zero as the distance from the center of the receptive field is increased. The second layer of the LRF model sums the weighted outputs of the first layer, which produces the output or response of the network. A supervised LMS rule is used to train the weights of the second layer nodes.

The response function of the LRF network is formulated as follows:
             f(x) = SUM(Ti * Ri(x)) where,
      Ri(x) = Q( ||x - xi|| / Wi )
      x - is a real valued vector in the input space,
      Ri - is the ith receptive field response function,
      Q - is a radially symmetric functio with a single
            maximum at the origin, decreasing to zero at
            large radii,
      xi - is the center of the ith receptive field,
      Wi - is the width of the ith receptive field,
      Ti - is the weight associated with each receptive field.

The receptive field response functions ( Ri(x) ), should be formulated such that they decrease rapidly with increasing radii. This ensures that the response functions provide highly localized representations of the input space. The response function used in this algorithm is modeled after the gaussian, and uses the trace of the covariance matrix to set the widths of the receptive field centers.

The number of receptive field response nodes in the first layer of the LRF is determined by the number of cluster centers in the "cluster center" image. The number of output classes, and hence the number of output nodes in the second (ie. last) layer of the LRF, is determined by the number of desired classes that was specified in the "supervised" classification phase of the clustering. This information is contained in the last band of the cluster center image. The number of weights in the network is determined by the number of receptive field response nodes and the number of output nodes. That is,
  #Wts = (#rf_response_nodes * #output_nodes) + #output_nodes

The resulting output image is classified with the desired number of classes specified in the last band of the "cluster center" (-i2) image. The number of desired classes corresponds to the number of output nodes in the last layer of the LRF network. This classified image is of data storage type INTEGER.

Input Arguments

The following arguments must be specified in the following order when calling this lib routine:

image
    is the original input image, which may be a multi-band image containing all of the feature bands used in the classification. This image MUST be of data storage type FLOAT.

cc_img
    is the "cluster center" image, which specifies the cluster center locations in the feature space. This image MUST contain the desired class information, obtained from the supervised classification step, as the last band in the image. Therefore this image will contain one more band than the input image. This image MUST be of data storage type FLOAT.

var_img
    is the "cluster variance" image, which specifies the variances of the data associated with each cluster center. This image should contain the same number of data bands as the input image. This image MUST be of data storage type FLOAT.

wt_img
    contains the "weights" for the LRF network after training on the input data using "lrftrain". The number of data bands in this image is equal to the number of (nodes + 1) in the LRF network. The number of columns in each band is equal to the number of desired/output classes for the LRF network. This image is stored as data storage type FLOAT.

border
    is an integer that specifies the border width, in pixels, encompassing the desired region of the image to be classified. This region is ignored during the classification process.

Output Arguments

class_img
    is the resulting classified image from the LRF classifier. This is a single band image that contains the class assignments for each pixel in the original input image. Its dimension is the same as the input image. The classification is based on the weights obtained from the training on a representative image. This image is stored as data type INTEGER.

This routine was written with the help of and ideas from Dr. Don Hush, University of New Mexico, Dept. of EECE.

SEE ALSO
lrfclass(1), intro(3), vipl(3), verror(3), vutils(3) llrftrain(3)

RESTRICTIONS
All input images MUST be of data storage type FLOAT. The resulting classified image (-o) is of data storage type INTEGER.

AUTHOR
Tom Sauer and Charlie Gage

COPYRIGHT
Copyright 1991, University of New Mexico. All rights reserved.