SURFDetector.hpp

/* $Id$ */

#ifndef _FDETECT_SURF_DETECTOR_HPP_
#define _FDETECT_SURF_DETECTOR_HPP_

#include <vector>

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

#include "fdetect/Detector.hpp"
#include "fdetect/FloatDescriptor.hpp"
#include "fdetect/RealDescriptor.hpp"

#include <opencv/cxcore.h>
#if CV_MAJOR_VERSION*10 + CV_MINOR_VERSION > 21
#include <opencv2/features2d/features2d.hpp>
#else
#include <cv.h>
#include <cv.hpp>
#endif

namespace jafar {
  namespace fdetect {
    class SURFDetector : public fdetect::Detector {
    private:
      cv::SURF cv_surf;
      std::vector<cv::KeyPoint> cv_keypoints;
      std::vector<float> cv_descriptors;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int /* file_version */){
  ar & cv_surf.hessianThreshold;
  ar & cv_surf.extended;
  ar & cv_surf.nOctaves;
  ar & cv_surf.nOctaveLayers;
      }
      
    public:
      SURFDetector(double _hessianThreshold = 500, int _nOctaves=4,
       int _nOctaveLayers=2, bool _extended=false);
      bool extended() const;
      double hessianThreshold() const;
      int octaves() const;
      int octaveLayers() const;
      void setExtended(bool _extended);
      void setHessianThreshold(double _hessianThreshold);
      void setOctaves(int _nOctave);
      void setOctaveLayers(int _nOctaveLayers);
      
      virtual fdetect::DetectionResult detectIn(jafar::image::Image const& image);
    };
  }
#ifndef SWIG
  namespace fdetect_v2 {
    template< typename InterestFeatureT >
    class SURFDetectorT : public fdetect_v2::Detector< InterestFeatureT >
    {
    private:
      cv::SURF cv_surf;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int /* file_version */){
        ar & cv_surf.hessianThreshold;
        ar & cv_surf.extended;
        ar & cv_surf.nOctaves;
        ar & cv_surf.nOctaveLayers;
      }
      
    public:
      typedef InterestFeatureT InterestFeatureType;
      typedef fdetect_v2::DetectionResult<InterestFeatureT> DetectionResult;
      SURFDetectorT(double _hessianThreshold = 500, int _nOctaves=4,
                   int _nOctaveLayers=2, bool _extended=false)
      {
        cv_surf.hessianThreshold = _hessianThreshold;
        cv_surf.extended = _extended;
        cv_surf.nOctaves = _nOctaves;
        cv_surf.nOctaveLayers = _nOctaveLayers;
      }
      ~SURFDetectorT() {}
      bool extended() const;
      double hessianThreshold() const;
      int octaves() const;
      int octaveLayers() const;
      void setExtended(bool _extended);
      void setHessianThreshold(double _hessianThreshold);
      void setOctaves(int _nOctave);
      void setOctaveLayers(int _nOctaveLayers);
      virtual DetectionResult detectIn(jafar::image::Image const& image) {
        return detectIn(image, jafar::image::Image(), true);
      }
      DetectionResult detectIn(jafar::image::Image const& image,
                               const jafar::image::Image& mask,
                               bool with_descriptors);
      void computeDescriptors(jafar::image::Image const& image, 
                              DetectionResult& dr) 
      {
        computeDescriptors(image, jafar::image::Image(), dr);
      }
      void computeDescriptors(jafar::image::Image const& image, 
                              const jafar::image::Image& mask,
                              DetectionResult& dr);
    };
    typedef SURFDetectorT<fdetect_v2::InterestFeature<fdetect_v2::FloatDescriptor> > SURFDetector;
  }
#endif
}
#include "fdetect/SURFDetector.hxx"
#endif