cvrEuclideanDistance.h

Go to the documentation of this file.

/*
 * Copyright (C) 1998 - 2005
 * Lehrstuhl fuer Technische Informatik, RWTH-Aachen, Germany
 *
 *
 * This file is part of the Computer Vision and Robotics Library (CVR-Lib)
 *
 * The CVR-Lib is free software; you can redistribute it and/or
 * modify it under the terms of the BSD License.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the authors nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */




/**
 * \file   cvrEuclideanDistance.h
 *         This file contains the functions T euclideanDistance(const
 *         T&, const T&) and T euclideanDistanceSqr(const T&, const
 *         T&) which calculate the Euclidean distance and its square,
 *         respectively.
 * \author Jochen Wickel
 * \date   28.06.2000
 *
 * $Id: cvrEuclideanDistance.h,v 1.2 2006/06/06 09:42:39 doerfler Exp $
 */

#ifndef _CVR_EUCLIDEAN_DISTANCE_H_
#define _CVR_EUCLIDEAN_DISTANCE_H_

#include <vector>
#include "cvrPoint.h"
#include "cvrPoint3D.h"
#include "cvrRGBPixel.h"
#include "cvrRGBAPixel.h"
#include "cvrVector.h"
#include "cvrMatrix.h"
#include "cvrDistanceType.h"

namespace cvr {

  /**
   * @name Euclidean Distances Functions
   * global functions to compute the L2 distance between two n-dimensional
   * point representations
   *
   * @ingroup gLinearAlgebra
   */
  //@{

  /**
   * Default implementation of the L2 distance between two values of
   * type T. It is assumed that T is scalar and an efficient
   * implementation is used. T must define the operator- and T must be
   * castable to distanceType<T>::square_distance_type, which in turn must be
   * a possible argument of cvr::abs().
   *
   * Overloads for most CVR-Lib types are implemented.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistance(const T& a, const T& b) {
    return abs(static_cast<typename distanceType<T>::square_distance_type>(a)
               -static_cast<typename distanceType<T>::square_distance_type>(b));
  }

  /**
   * euclideanDistance computes the L2 distance between
   * the vectors a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistance(const vector<T>& a,const vector<T>& b) {
    typename vector<T>::const_iterator ita,itb,ite;
    assert(a.size()==b.size());
    typename distanceType<T>::square_distance_type sum(0);
    for (ita=a.begin(),itb=b.begin(),ite=a.end();
         ita!=ite;
         ++ita,++itb) {
      const typename distanceType<T>::square_distance_type diff
        = static_cast<typename distanceType<T>::square_distance_type>(*ita)
        -static_cast<typename distanceType<T>::square_distance_type>(*itb);
      sum+=diff*diff;
    }
    return sqrt(sum);
  }

  /**
   * euclideanDistance computes the L2 distance between
   * the cvr::matrix a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistance(const matrix<T>& a,const matrix<T>& b) {
    assert(a.size() == b.size());

    typename matrix<T>::const_iterator ait,bit,eit;
    typename distanceType<T>::square_distance_type dist(0);
    ait = a.begin();
    bit = b.begin();
    eit = a.end();

    while (ait != eit) {
      const typename distanceType<T>::square_distance_type diff
        = static_cast<typename distanceType<T>::square_distance_type>(*ait)
        -static_cast<typename distanceType<T>::square_distance_type>(*bit);
      dist+=diff*diff;
      ++ait;
      ++bit;
    }
    return sqrt(dist);
  }


  /**
   * euclideanDistance computes the L2 distance between
   * the std::vectors a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistance(const std::vector<T>& a,const std::vector<T>& b) {
    typename std::vector<T>::const_iterator ita,itb,ite;
    assert(a.size()==b.size());
    typename distanceType<T>::square_distance_type sum(0);
    for (ita=a.begin(),itb=b.begin(),ite=a.end();
         ita!=ite;
         ++ita,++itb) {
      const typename distanceType<T>::square_distance_type diff
        = static_cast<typename distanceType<T>::square_distance_type>(*ita)
        -static_cast<typename distanceType<T>::square_distance_type>(*itb);
      sum+=diff*diff;
    }
    return sqrt(sum);
  }

  /**
   * euclideanDistance computes the L2 distance between
   * the points a and b.
   */
  template<class T >
  typename distanceType<T>::square_distance_type
  euclideanDistance(const point<T>& a,const point<T>& b) {
    return sqrt(static_cast<typename distanceType<T>::square_distance_type>
      (a.distanceSqr(b)));
  }

  /**
   * euclideanDistance computes the L2 distance between
   * the points a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistance(const point3D<T>& a, const point3D<T>& b) {
    return sqrt(static_cast<typename distanceType<T>::square_distance_type>
      (a.distanceSqr(b)));
  }

  /**
   * euclideanDistance computes the L2 distance between
   * the RGB values a and b in the RGB color space.
   */
  template<class T>
  inline typename distanceType<T>::square_distance_type
  euclideanDistance(const rgbPixel<T>& a, const rgbPixel<T>& b) {
    return sqrt(static_cast<typename distanceType<T>::square_distance_type>
       (a.distanceSqr(b)));
  }

  /**
   * euclideanDistance computes the L2 distance between
   * the RGB values a and b in the RGB color space.
   */
  inline distanceType<rgbaPixel>::square_distance_type
  euclideanDistance(const rgbaPixel& a, const rgbaPixel& b) {
    return cvr::sqrt(static_cast<distanceType<rgbaPixel>::square_distance_type>
      (a.distanceSqr(b)));
  }

  //@}

  /**
   * @name square of Euclidean Distances Functions
   *
   * global functions to compute the square of the L2 distance between
   * two n-dimensional point representations
   *
   * @ingroup gLinearAlgebra
   */
  //@{

  /**
   * Default implementation of the square of the L2 distance between
   * two values of type T. It is assumed that T is scalar and an
   * efficient implementation is used. T must define the operator- and
   * T must be castable to distanceType<T>::square_distance_type,
   * which in turn must be a possible argument of cvr::abs().
   *
   * Overloads for most CVR-Lib types are implemented.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistanceSqr(const T& a, const T& b) {
    const typename distanceType<T>::square_distance_type diff
      = static_cast<typename distanceType<T>::square_distance_type>(a)
      -static_cast<typename distanceType<T>::square_distance_type>(b);
    return diff*diff;
  }

  /**
   * euclideanDistanceSqr computes the L2 distance between
   * the vectors a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistanceSqr(const vector<T>& a,const vector<T>& b) {
    typename vector<T>::const_iterator ita,itb,ite;
    assert(a.size()==b.size());
    typename distanceType<T>::square_distance_type sum(0);
    for (ita=a.begin(),itb=b.begin(),ite=a.end();
         ita!=ite;
         ++ita,++itb) {
      const typename distanceType<T>::square_distance_type diff
        = static_cast<typename distanceType<T>::square_distance_type>(*ita)
        -static_cast<typename distanceType<T>::square_distance_type>(*itb);
      sum+=diff*diff;
    }
    return sum;
  }

  /**
   * euclideanDistanceSqr computes the L2 distance between
   * the cvr::matrix a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistanceSqr(const matrix<T>& a,const matrix<T>& b) {
    assert(a.size() == b.size());

    typename matrix<T>::const_iterator ait,bit,eit;
    typename distanceType<T>::square_distance_type dist(0);
    ait = a.begin();
    bit = b.begin();
    eit = a.end();

    while (ait != eit) {
      const typename distanceType<T>::square_distance_type diff
        = static_cast<typename distanceType<T>::square_distance_type>(*ait)
        -static_cast<typename distanceType<T>::square_distance_type>(*bit);
      dist+=diff*diff;
      ++ait;
      ++bit;
    }
    return dist;
  }


  /**
   * euclideanDistanceSqr computes the L2 distance between
   * the std::vectors a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistanceSqr(const std::vector<T>& a,const std::vector<T>& b) {
    typename std::vector<T>::const_iterator ita,itb,ite;
    assert(a.size()==b.size());
    typename distanceType<T>::square_distance_type sum(0);
    for (ita=a.begin(),itb=b.begin(),ite=a.end();
         ita!=ite;
         ++ita,++itb) {
      const typename distanceType<T>::square_distance_type diff
        = static_cast<typename distanceType<T>::square_distance_type>(*ita)
        -static_cast<typename distanceType<T>::square_distance_type>(*itb);
      sum+=diff*diff;
    }
    return sum;
  }

  /**
   * euclideanDistanceSqr computes the L2 distance between
   * the points a and b.
   */
  template<class T >
  typename distanceType<T>::square_distance_type
  euclideanDistanceSqr(const point<T>& a,const point<T>& b) {
    return static_cast<typename distanceType<T>::square_distance_type>
      (a.distanceSqr(b));
  }

  /**
   * euclideanDistanceSqr computes the L2 distance between
   * the points a and b.
   */
  template<class T>
  typename distanceType<T>::square_distance_type
  euclideanDistanceSqr(const point3D<T>& a, const point3D<T>& b) {
    return static_cast<typename distanceType<T>::square_distance_type>
      (a.distanceSqr(b));
  }

  /**
   * euclideanDistanceSqr computes the L2 distance between
   * the RGB values a and b in the RGB color space.
   */
  template<class T>
  inline typename distanceType<T>::square_distance_type
  euclideanDistanceSqr(const rgbPixel<T>& a, const rgbPixel<T>& b) {
    return static_cast<typename distanceType<T>::square_distance_type>
      (a.distanceSqr(b));
  }

  /**
   * euclideanDistanceSqr computes the L2 distance between
   * the RGB values a and b in the RGB color space.
   */
  inline distanceType<rgbaPixel>::square_distance_type
  euclideanDistanceSqr(const rgbaPixel& a, const rgbaPixel& b) {
    return static_cast<distanceType<rgbaPixel>::square_distance_type>
      (a.distanceSqr(b));
  }

  //@}


}

#endif