DetectionResult.hpp

/* $Id$ */

#ifndef _FDETECT_DETECTION_RESULT_HPP_
#define _FDETECT_DETECTION_RESULT_HPP_

#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/shared_ptr.hpp>

#include "fdetect/InterestFeature.hpp"

namespace jafar {
  namespace fdetect {
    class DetectionResult {
        struct Shared;
      public:
        DetectionResult();
        DetectionResult(const DetectionResult&);
        DetectionResult& operator=(const DetectionResult&);
        ~DetectionResult();
      public: 
        unsigned int id;
        // Access to features
        typedef vInterestFeatures_it iterator;
        typedef vInterestFeatures_cit const_iterator;
        unsigned int countInterestFeatures() const;
        unsigned int size() const { return countInterestFeatures(); }
        InterestFeature* operator[](int p);
        const InterestFeature* operator[](int p) const;
        vInterestFeatures_it beginFeatures();
        iterator begin() { return beginFeatures(); }
        vInterestFeatures_cit beginFeatures() const;
        const_iterator begin() const { return beginFeatures(); }
        vInterestFeatures_it endFeatures();
        iterator end() { return endFeatures(); }
        vInterestFeatures_cit endFeatures() const;
        const_iterator end() const { return endFeatures(); }
        void addFeature(InterestFeature* ife);
        void push_back(InterestFeature* ife) { addFeature(ife); }
      vInterestFeatures_it eraseFeature(vInterestFeatures_it it);
      iterator erase(iterator it) { return eraseFeature(it); }
      vInterestFeatures& getFeatures() const;
      DetectionResult filter(double threshold);
      
      friend std::ostream& operator <<(std::ostream& s, const DetectionResult& p_);
      friend std::ostream& operator <<(std::ostream& s, const DetectionResult::Shared& p_);
      
      private:
        void unref();
        Shared* m_shared;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version);
    };
  }

  namespace fdetect_v2 {
    template< typename InterestFeatureT >
    class DetectionResult {
    public:
      typedef std::vector< InterestFeatureT* > vInterestFeatures;
      typedef typename std::vector< InterestFeatureT* >::iterator iterator;
      typedef typename std::vector< InterestFeatureT* >::const_iterator const_iterator;
      typedef typename std::vector< InterestFeatureT* >::reverse_iterator 
      reverse_iterator;
      typedef typename std::vector< InterestFeatureT* >::const_reverse_iterator 
      const_reverse_iterator;
      
      DetectionResult() : id(-1), m_shared(new vInterestFeatures()) { }
      DetectionResult(const DetectionResult& dr) : id(dr.id), m_shared(dr.m_shared) {} 
      ~DetectionResult() {}
      unsigned int id;
      // Access to features
      unsigned int countInterestFeatures() const 
      { 
        return m_shared->size(); 
      }
      unsigned int size() const 
      { 
        return m_shared->size(); 
      }
      InterestFeatureT* operator[](int p) 
      { 
        return m_shared->at(p); 
      }
      const InterestFeatureT* operator[](int p) const
      { 
        return m_shared->at(p); 
      }
      iterator begin() 
      { 
        return m_shared->begin(); 
      }
      const_iterator begin() const
      { 
        return m_shared->begin(); 
      }
      reverse_iterator rbegin() 
      { 
        return m_shared->rbegin(); 
      }
      const_reverse_iterator rbegin() const
      { 
        return m_shared->rbegin(); 
      }
      iterator end()
      { 
        return m_shared->end(); 
      }
      const_iterator end() const
      { 
        return m_shared->end(); 
      }
      void push_back(InterestFeatureT* ife)
      {
        ife->setIndex(m_shared->size());
        m_shared->push_back(ife);
      }
      iterator erase(iterator it)
      {
        return m_shared->erase(it);
      }
      iterator erase(iterator first, iterator last) 
      {
        return m_shared->erase(first, last);
      }
      iterator erase(InterestFeatureT* ife)
      {
        iterator it = m_shared->begin() + ife->index();
        return m_shared->erase(it);
      }
      template <class InputIterator>
      void insert (InputIterator first, InputIterator last )
      {
        m_shared->insert(m_shared->end(), first, last);
      }
      void clean_indices()
      {
        //it is costing to get/check/set so just set
        for(unsigned int i = 0; i < size(); i++)
          m_shared->operator[](i)->setIndex(i);
      }
      void clear()
      {
        m_shared->clear();
        id = -1;
      }
      void clone(DetectionResult& dr)
      {
        dr.clear();
        for(const_iterator fit = this->begin(); fit != this->end(); ++fit)
          dr.push_back(new InterestFeatureT(*(*fit)));
      }

      vInterestFeatures& get() const 
      {
        return *m_shared;
      }
      DetectionResult filter(double threshold = 3.0)
      {
        DetectionResult result;
        for(iterator it = begin(); it != end(); ++it)
          if ((*it)->quality() >= threshold) 
            result.push_back(*it);
        return result;
      }
      friend std::ostream& operator <<(std::ostream& s, const fdetect_v2::DetectionResult<InterestFeatureT>& p_)
      {
        for(const_iterator it = p_.m_shared->begin(); it != p_.m_shared->end(); ++it)
          s << *(*it);
        s << "refcount " << p_.m_shared.use_count();
        return s;
      }

    private:
      boost::shared_ptr< vInterestFeatures > m_shared;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive &ar, const unsigned int version)
      {
        ar & id;
        ar & *m_shared;
      }
    };

  }

}

#endif