Descriptor.hpp

/* $Id$ */

#ifndef _FDETECT_DESCRIPTOR_HPP_
#define _FDETECT_DESCRIPTOR_HPP_

#include <iostream>

#include "image/Image.hpp"

#include "fdetect/InterestFeature.hpp"
#include "fdetect/DetectionResult.hpp"

namespace jafar {
  namespace fdetect {
    class InterestFeature;
    class Descriptor {
      public:
      Descriptor(InterestFeature* ip) : m_ip(ip) {};
      virtual ~Descriptor() {}
      public:
      virtual void print(std::ostream& s) const =0;
      virtual double weakComparison(Descriptor *) const =0;
      virtual double strongComparison(Descriptor *, double angle) const =0;
      virtual Descriptor* clone() = 0;
    protected:
      InterestFeature* interestFeature() const { return m_ip;}
    private:
      InterestFeature* m_ip;
      // //!!! nizar 20100912 : serialization stuff
      // friend class boost::serialization::access;
      // template<class Archive>
      // void serialize(Archive &ar, const unsigned int version) const
      // {  }
    };
    class DescriptorFactory {
    public:
      virtual ~DescriptorFactory() {}
      inline void createDescriptor(InterestFeature* ip, image::Image const& image) {
        jafar::fdetect::Descriptor* des = internalCreateDescriptor(ip, image);
        ip->setDescriptor(des);
      }
      inline void createDescriptor(DetectionResult vips, image::Image const& image) {
        for(vInterestFeatures_it it = vips.beginFeatures(); it != vips.endFeatures(); it++)
          {
            createDescriptor(*it, image);
          }
      }
    protected:
      virtual Descriptor* internalCreateDescriptor(InterestFeature* ip, image::Image const& image) = 0;
    };
    
  }

  namespace fdetect_v2 {
    class Descriptor 
    {
      public:
      enum Type {NONE, HARRIS, FLOAT, DOUBLE};
      Descriptor() {}
      virtual ~Descriptor() {}
      public:
      // /// print the descriptor values in a stream
      // virtual std::ostream operator<<(std::ostream& s, const fdetect_v2::Descriptor &d) const =0;
      virtual Type type() 
      {
        return NONE;
      };
    };

    template<typename InterestFeatureT>
    class DescriptorFactory 
    {
    public:
      typedef typename InterestFeatureT::DescriptorType DescriptorType;
      virtual ~DescriptorFactory() {}
      void createDescriptor(InterestFeatureT* ip, 
                            image::Image const& image) {
        DescriptorType des = internalCreateDescriptor(ip, image);
        ip->setDescriptor(des);
      }
      void createDescriptor(fdetect_v2::DetectionResult<InterestFeatureT> vips, 
                            image::Image const& image) {
        for(typename DetectionResult<InterestFeatureT>::const_iterator it = vips.begin(); 
            it != vips.end(); 
            ++it)
        {
          createDescriptor(*it, image);
        }
      }
    protected:
      virtual DescriptorType internalCreateDescriptor(InterestFeatureT* ip, image::Image const& image) = 0;
    };

  }
}

#endif