RealDescriptor.hpp

#ifndef _FDETECT_REAL_DESCRIPTOR_HPP_
#define _FDETECT_REAL_DESCRIPTOR_HPP_

#include <boost/serialization/vector.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include "fdetect/Descriptor.hpp"

namespace jafar {
  namespace fdetect_v2 {
    template<typename REALTYPE>
    class RealDescriptor : public jafar::fdetect_v2::Descriptor {
    public:
      typedef REALTYPE RealType;
      RealDescriptor() : m_descr(0), m_normalizeCoef(1.0) {};
      RealDescriptor(const std::vector<REALTYPE> &descr, 
                     REALTYPE normalizeCoef) : 
        fdetect_v2::Descriptor(), m_descr(descr), m_normalizeCoef(normalizeCoef) {}
      template <typename InputIterator>
      RealDescriptor(InputIterator begin, InputIterator end,
                         REALTYPE normalizeCoef) :
        fdetect_v2::Descriptor(), m_descr(begin, end), m_normalizeCoef(normalizeCoef) {}
      REALTYPE weakComparison(const jafar::fdetect_v2::RealDescriptor<REALTYPE>& snd)
      {
        return strongComparison(snd, 0.0);
      }
      REALTYPE strongComparison(const jafar::fdetect_v2::RealDescriptor<REALTYPE> &snd, REALTYPE angle) 
      {
        REALTYPE v = 0.0;
        typename std::vector<REALTYPE>::const_iterator it, it2;
        for(it = m_descr.begin(), it2 = snd.m_descr.begin(); 
          it != m_descr.end(); 
          ++it, ++it2) {
        REALTYPE vb = (*it) - (*it2);
        v += vb * vb; 
        /*    if( m_descr[i] < d2.m_descr[i])
              {
              v += m_descr[i] / d2.m_descr[i];
              } else {
              v += d2.m_descr[i] / m_descr[i];
              }*/
      }
      //   JFR_DEBUG(v << " " << m_descLength << " " << (v / m_descLength) );
      return 1.0 - v * m_normalizeCoef;
      }

    public:
      std::vector<REALTYPE> m_descr;
      REALTYPE m_normalizeCoef;
      size_t size() const { return m_descr.size(); }
      virtual Type type() { return Descriptor::FLOAT; }
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & m_normalizeCoef;
        ar & m_descr;
      }
    };
    typedef RealDescriptor<float> FloatDescriptor;
    typedef RealDescriptor<double> DoubleDescriptor;
    template<typename T>
    std::ostream& operator<<(std::ostream& s, const RealDescriptor<T>& fd)
    {
      s << " Real Descriptor : ( ";
      std::copy(fd.m_descr.begin(), fd.m_descr.end(),
                std::ostream_iterator<T>(s, " "));
      s << ")";
      return s;
    }
  }
}

#endif