InterestFeature.hpp

/* $Id$ */

#ifndef _FDETECT_INTERESTFEATURE_HPP_
#define _FDETECT_INTERESTFEATURE_HPP_

#include <iostream>
#include <vector>
#include <map>

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/optional.hpp>
#include <boost/optional.hpp>
#include "geom/InterestPoint.hpp"
#include "jmath/jblas.hpp"

namespace jafar {
  namespace fdetect {
    class Descriptor;
    class InterestFeature : public geom::InterestPoint {

    public:
      InterestFeature() : InterestPoint(), m_descriptor(NULL) {}
      InterestFeature(double u, double v) : InterestPoint(u,v), m_descriptor(NULL) { }
      InterestFeature(InterestFeature const& m) { copy(m); }
      InterestFeature& operator=(InterestFeature const& m);
      ~InterestFeature();
      void setDescriptor(Descriptor* descriptor);
      inline Descriptor* descriptor() const { return m_descriptor; }
      unsigned int parent_id;

    private:
      Descriptor* m_descriptor;
      void copy(const InterestFeature& m);
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int /* file_version */){
        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(geom::InterestPoint);
        ar & *m_descriptor;
      }
    };
    //    BOOST_IS_ABSTRACT(geom::InterestPoint)

    typedef std::vector<jafar::fdetect::InterestFeature*> vInterestFeatures;
    typedef vInterestFeatures::iterator vInterestFeatures_it;
    typedef vInterestFeatures::const_iterator vInterestFeatures_cit;
    typedef std::map<double, jafar::fdetect::InterestFeature*> double2InterestFeature;
#ifndef SWIG
    std::ostream& operator <<(std::ostream& s, const InterestFeature& p_);
#endif

  }

  namespace fdetect_v2 {
    template<typename DESCRIPTOR>
    class InterestFeature : public geom::InterestPoint {

    public:
      typedef DESCRIPTOR DescriptorType;
      InterestFeature() : InterestPoint() { }
      InterestFeature(double u, double v) : InterestPoint(u,v) { }
      InterestFeature(double u, double v, float size, float angle) : 
        InterestPoint(u,v) 
      { 
        m_size.reset(size);
        m_angle.reset(angle);
      }
      void setDescriptor(const DescriptorType& descriptor) {
        m_descriptor = descriptor;
      };
      const DescriptorType& descriptor() const 
      { 
        return m_descriptor; 
      }
      DescriptorType& descriptor() 
      { 
        DescriptorType& desc_ref = m_descriptor;
        return desc_ref; 
      }
      unsigned int parent_id;
      void setSize(float size) { m_size.reset(size); }
      void setAngle(float angle) { m_angle.reset(angle); }
      float const* size() const { return get_pointer(m_size); }
      float const* angle() const { return get_pointer(m_angle); }
      
    private:
      boost::optional<float> m_size;
      boost::optional<float> m_angle;
      DescriptorType m_descriptor;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int /* file_version */){
        ar & boost::serialization::base_object<geom::InterestPoint>(*this);
        ar & m_descriptor;
        ar & m_size;
        ar & m_angle;
      }
    };

    template<typename DESCRIPTOR, typename T>
    class InterestFeatureWithData : public InterestFeature<DESCRIPTOR> 
    {
    public:
      typedef T DataType;
      
      InterestFeatureWithData() : 
        InterestFeature<DESCRIPTOR>() {}
      InterestFeatureWithData(double u, double v) : 
        InterestFeature<DESCRIPTOR>(u,v) {}
      InterestFeatureWithData(double u, double v, float size, float angle) : 
        InterestFeature<DESCRIPTOR>(u,v,size,angle) {}
      void setData(const T& data) 
      {
        m_data = data;
      }
      T getData() 
      {
        return m_data;
      }
    private:
      T m_data;
    };
    //    BOOST_IS_ABSTRACT(geom::InterestPoint)
    // template <typename DescriptorType>
    // typedef std::vector< jafar::fdetect::InterestFeature< DescriptorType > > vInterestFeatures2;
    // typedef vInterestFeatures2::iterator vInterestFeatures2_it;
    // typedef vInterestFeatures2::const_iterator vInterestFeatures2_cit;
    // template <typename DescriptorType>
    // typedef std::map<double, jafar::fdetect::InterestFeature< DescriptorType > > double2InterestFeature;
#ifndef SWIG
    template <typename DESCRIPTOR>
    std::ostream& operator <<(std::ostream& s, const InterestFeature< DESCRIPTOR >& p_)
    {
      s << "id: "<< p_.id() << " ";
      s << "position: " << p_.u() << "," << p_.v() << " "; 
      s << "descriptor: " << p_.descriptor();
      return s;
    }
#endif

  }
}

#endif