org.openimaj.feature

Enum SparseByteFVComparison

java.lang.Object

java.lang.Enum<SparseByteFVComparison>

org.openimaj.feature.SparseByteFVComparison

All Implemented Interfaces:

Serializable, Comparable<SparseByteFVComparison>, FVComparator<SparseByteFV>, DistanceComparator<SparseByteFV>

public enum SparseByteFVComparison
extends Enum<SparseByteFVComparison>
implements FVComparator<SparseByteFV>

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(SparseByteArray h1, SparseByteArray h2) Compare two feature vectors in the form of sparse arrays, returning a score or distance.
double	compare(SparseByteFV h1, SparseByteFV h2) Compare two objects, returning a score or distance.
boolean	isDistance()
static SparseByteFVComparison	valueOf(String name) Returns the enum constant of this type with the specified name.
static SparseByteFVComparison[]	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 SparseByteFVComparison EUCLIDEAN

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

CORRELATION

public static final SparseByteFVComparison 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 SparseByteFVComparison CHI_SQUARE

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

INTERSECTION

public static final SparseByteFVComparison INTERSECTION

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

BHATTACHARYYA

public static final SparseByteFVComparison 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 SparseByteFVComparison HAMMING

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

PACKED_HAMMING

public static final SparseByteFVComparison PACKED_HAMMING

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

CITY_BLOCK

public static final SparseByteFVComparison CITY_BLOCK

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

COSINE_SIM

public static final SparseByteFVComparison 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 SparseByteFVComparison COSINE_DIST

Cosine distance (-COSINE_SIM)

ARCCOS

public static final SparseByteFVComparison ARCCOS

The arccosine of the cosine similarity

SYMMETRIC_KL_DIVERGENCE

public static final SparseByteFVComparison 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 SparseByteFVComparison JACCARD_DISTANCE

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

Method Detail

values

public static SparseByteFVComparison[] 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 (SparseByteFVComparison c : SparseByteFVComparison.values())
    System.out.println(c);

Returns:

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

valueOf

public static SparseByteFVComparison 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<SparseByteFV>

Returns:

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

compare

public double compare(SparseByteFV h1,
             SparseByteFV h2)

Description copied from interface: DistanceComparator

Compare two objects, returning a score or distance.

Specified by:

compare in interface DistanceComparator<SparseByteFV>

Parameters:

h1 - the first object

h2 - the second object

Returns:

a score or distance

compare

public abstract double compare(SparseByteArray h1,
             SparseByteArray 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