Documentation - C API
LIOP fundamentals

Local Invariant Order Pattern (LIOP) descriptor, as proposed in [24] , uses both local and overall intensity information of the local patch for the descriptor computation. It is invariant to monotonic intensity changes and image rotation and is robust to many other geometric and photometric transformations.

The descriptor is computed from a normalized local patch. An image part that belongs to a feature frame which can be generally of shape of an oriented ellise is transformed to a circle.

In this implementation, we are computing the LIOP descriptor from a patch which is represented by a square of an odd side length. Only points belonging to the area of a circle of a radius which is always smaller than half of the patch side will be used as sample points.

Descriptor computation

The descriptor computation has 2 steps based on intensity order. First, every sample point is assigned to a particular bin according to overall intensity. Second, intensities of neighbours of sample points contribute to actuall values of the computed descriptor.

Region division

All sample points are sorted according to their intensity in a nondescending order. The points are than equally quantized into numberOfBins ordinal bins.

As a result, each bin contains the same number of points except for the last one which is between 0 to numberOfBins - 1 points larger. The first bin contains points with the lowest intensity values, similarly the last bin has the points with the highest intensity values.

(parameter to set numberOfBins)

Sample point contribution

Each point is represented by its neighbours. Specifically, numberOfNeighbours points are sampled from a circle of radius pointToNeighbourRadius and centre in the particular point. The neighbouring points are sampled in the same manner as shown on the image below ( \(C\) is the patch center). Sampling order is always anticlokwise.

liop-neighbours-sampling.png
Sampling order of neighbouring points

Intensity values of these neighbouring points are computed by linear interpolation.

We sort the neighbours according their intensities and take the indexes that points from the sorted array into the unsorted one. Then the permutation index is computed.

\[ [ I( N_{1}) \; I( N_{2} ) \; I(N_{3}) \; I( N_{4}) ] = [ 86 \; 217 \; 152 \; 101]\rightarrow ( 1 \; 4 \; 3 \; 2 )\rightarrow 6 \]

The permutation index is computed so that it fits the table below.

Array indexes Permutation index
1 2 3 4 0
1 2 4 3 1
1 3 2 4 2
1 3 4 2 3
1 4 2 3 4
1 4 3 2 5
2 1 3 4 6
2 1 4 3 7
... ...
4 3 1 2 22
4 3 2 1 23

Each bin forms a factorial() length descriptor. Each point increments the element of the bin descriptor at position of its permutation index. How much the element will be incremented is determined by a weighting function.

Weighting function

The bigger difference is between intensities of all neighbours of a particular point, the bigger weight is assigned. (In the following equation the \(Th\) stands for weightThreshold.)

\[ w = \sum \limits_{i,j} sgn( | I( N_{i} )- I( N_{j} )| - Th) + 1 \]

If \(w > 0\) the particular element is increased by w, by 1 otherwise.

(parameters to set numberOfNeighbours, pointToNeighbourRadius and weightThreshold)

Concatenation

As the last step, descriptors of all bins are concatenated together. Therefore, the first group of factorial() elements of the descriptor come from the first bin, the second group of factorial() elements represents the second bin ect.

The final step is normalization of the descriptor \(\phi\).

\[ \frac{\phi}{\|\phi\|}\times255 \]