35 #ifndef VIGRA_METRIC_HXX 
   36 #define VIGRA_METRIC_HXX 
   38 #include <vigra/numerictraits.hxx> 
   39 #include <vigra/multi_array.hxx> 
   57         T operator()(
const T & a,
const T & b)
const{
 
   58             return opImpl(&a,&a+1,&b);
 
   60         template<
class A, 
class B>
 
   61         T operator()(
const A & a,
const B & b)
const{
 
   62             return opImpl(a.begin(),a.end(),b.begin());
 
   65         template<
class ITER_A,
class ITER_B>
 
   67             ITER_A  iterA  ,ITER_A  endA   ,ITER_B  iterB
 
   71                 const T aa=
static_cast<T
>(*iterA);
 
   72                 const T bb=
static_cast<T
>(*iterB);
 
   73                 const T 
sum  = aa + bb;
 
   74                 const T diff = aa - bb;
 
   75                 if(sum> static_cast<T>(0.0000001))
 
   85     class HellingerDistance{
 
   88         T operator()(
const T & a,
const T & b)
const{
 
   89             return opImpl(&a,&a+1,&b);
 
   91         template<
class A, 
class B>
 
   92         T operator()(
const A & a,
const B & b)
const{
 
   93             return opImpl(a.begin(),a.end(),b.begin());
 
   96         template<
class ITER_A,
class ITER_B>
 
   98             ITER_A  iterA  ,ITER_A  endA   ,ITER_B  iterB
 
  102                 const T aa=
std::sqrt(static_cast<T>(*iterA));
 
  103                 const T bb=
std::sqrt(static_cast<T>(*iterB));
 
  104                 const T diff = aa - bb;
 
  113     template<
class T,
unsigned int NORM,
bool TAKE_ROOT=true>
 
  117         T operator()(
const T & a,
const T & b)
const{
 
  118             return opImpl(&a,&a+1,&b);
 
  120         template<
class A, 
class B>
 
  121         T operator()(
const A & a,
const B & b)
const{
 
  122             return opImpl(a.begin(),a.end(),b.begin());
 
  125         template<
class ITER_A,
class ITER_B>
 
  127             ITER_A  iterA  ,ITER_A  endA   ,ITER_B  iterB
 
  129             T res = 
static_cast<T
>(0.0);
 
  131                 const T aa=
static_cast<T
>(*iterA);
 
  132                 const T bb=
static_cast<T
>(*iterB);
 
  133                 const T diff = aa-bb;
 
  134                 res+= 
std::abs(std::pow((
double)diff,(
int)NORM));
 
  138             return TAKE_ROOT ? std::pow(res,static_cast<T>(1)/static_cast<T>(NORM)) : res;
 
  144     :  
public PNorm<T,2,false>{
 
  147         :   PNorm<T,2,false>(){
 
  153     :  
public PNorm<T,2,true>{
 
  162     :  
public PNorm<T,1,false>{
 
  165         :   PNorm<T,1,false>(){
 
  170     class SymetricKlDivergenz{
 
  172         SymetricKlDivergenz(){}
 
  173         T operator()(
const T & a,
const T & b)
const{
 
  174             return opImpl(&a,&a+1,&b);
 
  176         template<
class A, 
class B>
 
  177         T operator()(
const A & a,
const B & b)
const{
 
  178             return opImpl(a.begin(),a.end(),b.begin());
 
  181         template<
class ITER_A,
class ITER_B>
 
  183             ITER_A  iterA  ,ITER_A  endA   ,ITER_B  iterB
 
  185             T res = 
static_cast<T
>(0.0);
 
  187                 const T aa=
static_cast<T
>(*iterA);
 
  188                 const T bb=
static_cast<T
>(*iterB);
 
  189                 const T val = 
std::log(aa/bb)*(aa - bb);
 
  190                 if(!isinf(val) && !isnan(val))
 
  195             return res/
static_cast<T
>(2.0);
 
  200     class BhattacharyaDistance{
 
  202         BhattacharyaDistance(){}
 
  203         T operator()(
const T & a,
const T & b)
const{
 
  204             return opImpl(&a,&a+1,&b);
 
  206         template<
class A, 
class B>
 
  207         T operator()(
const A & a,
const B & b)
const{
 
  208             return opImpl(a.begin(),a.end(),b.begin());
 
  211         template<
class ITER_A,
class ITER_B>
 
  213             ITER_A  iterA  ,ITER_A  endA   ,ITER_B  iterB
 
  215             T res = 
static_cast<T
>(0.0);
 
  217                 const T aa=
static_cast<T
>(*iterA);
 
  218                 const T bb=
static_cast<T
>(*iterB);
 
  223             return std::sqrt( static_cast<T>(1.0)-res);
 
  259         : metricType_(metricType){
 
  263         template<
class A, 
class B>
 
  264         T operator()(
const A & a,
const B & b)
const{
 
  265             switch(static_cast<unsigned int>(metricType_)){
 
  267                     return chiSquared_(a,b);
 
  269                     return hellingerDistance_(a,b);
 
  271                     return squaredNorm_(a,b);
 
  275                     return manhattan_(a,b);
 
  277                     return symetricKlDivergenz_(a,b);
 
  279                     return bhattacharyaDistance_(a,b);
 
  286         ChiSquared<T> chiSquared_;
 
  287         HellingerDistance<T> hellingerDistance_;
 
  288         SquaredNorm<T> squaredNorm_;
 
  290         Manhattan<T> manhattan_;
 
  291         SymetricKlDivergenz<T> symetricKlDivergenz_;
 
  292         BhattacharyaDistance<T> bhattacharyaDistance_;
 
  300 #endif //VIGRA_METRIC_HXX 
Euclidean distance (L2 norm) 
Definition: metrics.hxx:234
Functor to compute a metric between two vectors. 
Definition: metrics.hxx:250
Metric(const MetricType metricType=ManhattanMetric)
Construct functor for the given metric. 
Definition: metrics.hxx:258
Manhattan distance (L1 norm) 
Definition: metrics.hxx:236
Bhattacharya distance (sum of elementwise geometric means) 
Definition: metrics.hxx:239
Manhattan distance (L1 norm) 
Definition: metrics.hxx:237
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements 
Definition: tinyvector.hxx:2073
MetricType
Tags to select a metric for vector distance computation. 
Definition: metrics.hxx:229
chi-squared distance for histograms (sum of squared differences normalized by means) ...
Definition: metrics.hxx:231
squared Euclidean distance 
Definition: metrics.hxx:233
linalg::TemporaryMatrix< T > log(MultiArrayView< 2, T, C > const &v)
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude) 
Definition: fftw3.hxx:1002
Hellinger distance (Euclidean distance between the square-root vectors) 
Definition: metrics.hxx:232
symmetric Kullback-Leibler divergence 
Definition: metrics.hxx:238
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root. 
Definition: fixedpoint.hxx:616
Euclidean distance (L2 norm) 
Definition: metrics.hxx:235