create_class_lut_knn — Create a look-up table using a k-nearest neighbors
classifier (k-NN) to classify byte
images.
create_class_lut_knn( : : KNNHandle, GenParamName, GenParamValue : ClassLUTHandle)
create_class_lut_knn generates a look-up table (LUT)
ClassLUTHandle using the data of a trained k-nearest neighbors
classifier (k-NN) KNNHandle to classify multi-channel byte images.
By using this k-NN-based LUT classifier, the operator
classify_image_class_knn of the subsequent classification can be
replaced by the operator classify_image_class_lut. The
classification is speed up considerably, because the estimation
of the class in every image point is no longer
necessary since every possible response of the k-NN is stored in the LUT.
For the generation of the LUT, the parameter NumDim of
called operator create_class_knn is important.
The number of image channels the images must have to be
classified is defined in NumDim.
To create the LUT,
all pixel values are classified with classify_class_knn.
The returned classes are stored in the LUT. Because of the discretization
of the LUT, the accuracy of the LUT classifier could become lower than the
accuracy of classify_image_class_knn.
With 'bit_depth' the accuracy of the classification, the required storage, and the runtime needed to create the LUT can be controlled.
The following parameters of the k-NN-based LUT classifier can be set with
GenParamName and GenParamValue:
Number of bits used from the pixels. It controls the storage requirement
of the LUT classifier and is bounded by the bit depth of the image
('bit_depth' <= 8). If the bit depth of the
LUT is smaller ('bit_depth' < 8), the classes
of multiple pixel combinations will be mapped to the same LUT entry,
which can result in a lower accuracy for the classification. One of these
clusters contains
pixel combinations,
where NumDim denotes the dimension of the LUT, which is
specified in create_class_knn. For example,
for 'bit_depth' = 7,
NumDim = 3, the classes of 8 pixel
combinations are mapped in the same LUT entry. The LUT requires at most
bytes of storage.
For example, for NumDim = 3,
'bit_depth' = 8 and number of classes is smaller than
16, the LUT requires 8 MB of storage
with internal storage optimization.
The runtime for the classification in classify_image_class_lut
becomes minimal if the LUT fits into the cache.
The default value is 8,
typical values are [6,7,8].
Restrictions: 'bit_depth' >= 1,
'bit_depth' <= 8.
Threshold for the rejection of uncertain classified points of the k-NN.
The parameter represents a threshold on the distance
returned by the classification (see classify_class_knn).
All pixels having a distance over
'rejection_threshold' are not assigned to any class.
The default value is 5.
Restriction: 'rejection_threshold' >= 0.
This operator returns a handle. Note that the state of an instance of this handle type may be changed by specific operators even though the handle is used as an input parameter by those operators.
KNNHandle (input_control) class_knn → (handle)
Handle of the k-NN classifier.
GenParamName (input_control) attribute.name-array → (string)
Names of the generic parameters that can be adjusted for the LUT classifier creation.
Default value: []
Suggested values: 'bit_depth', 'rejection_threshold'
GenParamValue (input_control) attribute.value-array → (string / integer / real)
Values of the generic parameters that can be adjusted for the LUT classifier creation.
Default value: []
Suggested values: 8, 7, 6, 0.5, 5, 10, 50
ClassLUTHandle (output_control) class_lut → (handle)
Handle of the LUT classifier.
If the parameters are valid, the operator create_class_lut_knn
returns the value 2 (H_MSG_TRUE). If necessary an exception is raised.
train_class_knn,
read_class_knn
create_class_lut_svm,
create_class_lut_gmm,
create_class_lut_mlp
classify_image_class_lut,
clear_class_lut
Foundation