org.openimaj.feature

Enum SparseShortFVComparison

java.lang.Object

java.lang.Enum<SparseShortFVComparison>

org.openimaj.feature.SparseShortFVComparison

All Implemented Interfaces:

Serializable, Comparable<SparseShortFVComparison>, FVComparator<SparseShortFV>, DistanceComparator<SparseShortFV>

public enum SparseShortFVComparison
extends Enum<SparseShortFVComparison>
implements FVComparator<SparseShortFV>

Comparison/distance methods for DoubleFV objects.

Author:

Jonathon Hare (jsh2@ecs.soton.ac.uk)

Enum Constant Summary

Enum Constants

Enum Constant and Description
ARCCOS The arccosine of the cosine similarity
BHATTACHARYYA Bhattacharyya distance d(H1,H2) = sqrt( 1 - (1 / sqrt(sumI(H1(I)) * sumI(H2(I))) ) * sumI( sqrt(H1(I) * H2(I)) ) )
CHI_SQUARE Chi-squared distance d(H1,H2) = 0.5 * sumI[(H1(I)-H2(I))^2 / (H1(I)+H2(I))]
CITY_BLOCK City-block (L1) distance d(H1,H2) = sumI( abs(H1(I)-H2(I)) )
CORRELATION Correlation d(H1,H2) = sumI( H'1(I) * H'2(I) ) / sqrt( sumI[H'1(I)2]^2 * sumI[H'2(I)^2] ) where H'k(I) = Hk(I) - (1/N) * sumJ( Hk(J) ); N=number of FeatureVector bins
COSINE_DIST Cosine distance (-COSINE_SIM)
COSINE_SIM Cosine similarity (sim of 1 means identical) d(H1,H2)=sumI(H1(I) * H2(I))) / (sumI(H1(I)^2) sumI(H2(I)^2))
EUCLIDEAN Euclidean distance d(H1,H2) = Math.sqrt( sumI( (H1(I)-H2(I))^2 ) )
HAMMING Hamming Distance d(H1,H2) = sumI(H1(I) == H2(I) ? 1 : 0)
INTERSECTION Histogram intersection; assumes all values > 0.
JACCARD_DISTANCE Jaccard distance.
PACKED_HAMMING Hamming Distance for packed bit strings d(H1,H2) = sumI(H1(I) == H2(I) ? 1 : 0)
SYMMETRIC_KL_DIVERGENCE The symmetric Kullback-Leibler divergence.

Method Summary

Methods

Modifier and Type	Method and Description
abstract double	compare(SparseShortArray h1, SparseShortArray h2) Compare two feature vectors in the form of sparse arrays, returning a score or distance.
double	compare(SparseShortFV h1, SparseShortFV h2) Compare two objects, returning a score or distance.
boolean	isDistance()
static SparseShortFVComparison	valueOf(String name) Returns the enum constant of this type with the specified name.
static SparseShortFVComparison[]	values() Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum

clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Enum Constant Detail

EUCLIDEAN

public static final SparseShortFVComparison EUCLIDEAN

Euclidean distance d(H1,H2) = Math.sqrt( sumI( (H1(I)-H2(I))^2 ) )

CORRELATION

public static final SparseShortFVComparison CORRELATION

Correlation d(H1,H2) = sumI( H'1(I) * H'2(I) ) / sqrt( sumI[H'1(I)2]^2 * sumI[H'2(I)^2] ) where H'k(I) = Hk(I) - (1/N) * sumJ( Hk(J) ); N=number of FeatureVector bins

CHI_SQUARE

public static final SparseShortFVComparison CHI_SQUARE

Chi-squared distance d(H1,H2) = 0.5 * sumI[(H1(I)-H2(I))^2 / (H1(I)+H2(I))]

INTERSECTION

public static final SparseShortFVComparison INTERSECTION

Histogram intersection; assumes all values > 0. d(H1,H2) = sumI( min(H1(I), H2(I)) )

BHATTACHARYYA

public static final SparseShortFVComparison BHATTACHARYYA

Bhattacharyya distance d(H1,H2) = sqrt( 1 - (1 / sqrt(sumI(H1(I)) * sumI(H2(I))) ) * sumI( sqrt(H1(I) * H2(I)) ) )

HAMMING

public static final SparseShortFVComparison HAMMING

Hamming Distance d(H1,H2) = sumI(H1(I) == H2(I) ? 1 : 0)

PACKED_HAMMING

public static final SparseShortFVComparison PACKED_HAMMING

Hamming Distance for packed bit strings d(H1,H2) = sumI(H1(I) == H2(I) ? 1 : 0)

CITY_BLOCK

public static final SparseShortFVComparison CITY_BLOCK

City-block (L1) distance d(H1,H2) = sumI( abs(H1(I)-H2(I)) )

COSINE_SIM

public static final SparseShortFVComparison COSINE_SIM

Cosine similarity (sim of 1 means identical) d(H1,H2)=sumI(H1(I) * H2(I))) / (sumI(H1(I)^2) sumI(H2(I)^2))

COSINE_DIST

public static final SparseShortFVComparison COSINE_DIST

Cosine distance (-COSINE_SIM)

ARCCOS

public static final SparseShortFVComparison ARCCOS

The arccosine of the cosine similarity

SYMMETRIC_KL_DIVERGENCE

public static final SparseShortFVComparison SYMMETRIC_KL_DIVERGENCE

The symmetric Kullback-Leibler divergence. Vectors must only contain positive values; internally they will be converted to double arrays and normalised to sum to unit length.

JACCARD_DISTANCE

public static final SparseShortFVComparison JACCARD_DISTANCE

Jaccard distance. Converts each vector to a set for comparison.

Method Detail

values

public static SparseShortFVComparison[] values()

Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:

for (SparseShortFVComparison c : SparseShortFVComparison.values())
    System.out.println(c);

Returns:

an array containing the constants of this enum type, in the order they are declared

valueOf

public static SparseShortFVComparison valueOf(String name)

Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)

Parameters:

name - the name of the enum constant to be returned.

Returns:

the enum constant with the specified name

Throws:

IllegalArgumentException - if this enum type has no constant with the specified name

NullPointerException - if the argument is null

isDistance

public boolean isDistance()

Specified by:

isDistance in interface DistanceComparator<SparseShortFV>

Returns:

true if the comparison is a distance; false if similarity.

compare

public double compare(SparseShortFV h1,
             SparseShortFV h2)

Description copied from interface: DistanceComparator

Compare two objects, returning a score or distance.

Specified by:

compare in interface DistanceComparator<SparseShortFV>

Parameters:

h1 - the first object

h2 - the second object

Returns:

a score or distance

compare

public abstract double compare(SparseShortArray h1,
             SparseShortArray h2)

Compare two feature vectors in the form of sparse arrays, returning a score or distance.

Parameters:

h1 - the first feature array

h2 - the second feature array

Returns:

a score or distance