Lince - An Artificial Vision Library and Applications.
How it works.
Lince is based on the comparison between shapes and the relations between
these with the ones previously learned. There are a lot of advantages for
using the training technique:
No need for explicit object recognition in the code.
Dynamic learning of new objects while executing the program
The recognition is divided in three steps:
- The first step consists in a traditional preprocessing that improves performance.
As the development in the other two parts advances, this step will loose importance
until it disappears completely.
- The second step converts the image into a group of shapes, where a shape is a set
of points joined one after another and the first with the last one, similar to a
polygon in a vector graphics editor.
is transformed to a shape,
internally is converted to a list of vectors:
The reason for this conversion is mainly that it is easier to
work with a one dimensional list of numbers than a two dimensional grid of pixels,
the recognition process is simplified and we abandon the image and work
with more abstract entities.
- The last part is the most creative one to implement, and it divides in two:
- Shape recognition
- This will search in the database for similar shapes, and for each one
return the probability of matching that shape.
In huge databases, a hash table may be needed to speed up things.
- Object recognition
- An object is represented internally by a list of shapes. The core of
the recognition lives here. The probabilities of the individual shapes are read
and compared to each one of the internal object, and, as this will lead to a lot
of shapes being similar, a selection is being done based on the position,
rotation, size and other properties of
each shape relative to our internal object. The object that fits best with the
shapes extracted from the object is the one that is chosen.
Currently there is nothing finished, but a simple letter recognition is almost done.
The first application (not really useful, though) is to solve letter soups.
The letters are clear enough to recognize them successfully with a very
basic implementation of the algorithm.
Copyleft 2005 Paco Arjonilla