SIFTDetector.hpp

#ifndef _FDETECT_SIFT_DETECTOR_HPP_
#define _FDETECT_SIFT_DETECTOR_HPP_

#ifdef HAVE_SIFT

#include <cv.h>
#include <cv.hpp>

extern "C" {
#include <sift.h>
}

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

#include "fdetect/Detector.hpp"

namespace jafar {
  namespace fdetect {
    class SIFTDetector : public fdetect::Detector {
    private:
      struct feature* detectedFeatures;
      int m_intervals;
      double m_sigma;
      double m_contrastThreshold;
      int m_curvatureThreshold;
      bool m_doubleImageSize;
      int m_descriptorHistogramWidth;
      int m_descriptorHistogramBins;

      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int /* file_version */){
  ar & m_intervals;
  ar & m_sigma;
  ar & m_contrastThreshold;
  ar & m_curvatureThreshold;
  ar & m_doubleImageSize;
  ar & m_descriptorHistogramWidth;
  ar & m_descriptorHistogramBins;
      }

    public:
      SIFTDetector(const int& intervals = 3, const double& sigma = 1.6, 
       const double& contrastThreshold = 0.04, const int& curvatureThreshold = 10,
       const bool& doubleImageSize = true, const int& descriptorHistogramWidth = 4,
       const int& descriptorHistogramBins = 8);
      int intervals() const;
      double sigma() const;
      double contrastThreshold() const;
      int curvatureThreshold() const;
      bool doubleImageSize() const;
      int descriptorHistogramWidth() const;
      int descriptorHistogramBins() const;

      void setIntervals(const int& intervals);
      void setSigma(const double& sigma);
      void setContrastThreshold(const double& contrastThreshold);
      void setCurvatureThreshold(const int& curvatureThreshold);
      void setDoubleImageSize(const bool& doubleImageSize);
      void setDescriptorHistogramWidth(const int& descriptorHistogramWidth);
      void setDescriptorHistogramBins(const int& descriptorHistogramBins);
      
      virtual fdetect::DetectionResult detectIn(jafar::image::Image const& image);
    };
  }
}

#else
#include <opencv/cxcore.h>
#if CV_MAJOR_VERSION*10 + CV_MINOR_VERSION > 21
#include <opencv2/features2d/features2d.hpp>
#include "fdetect/Detector.hpp"
#include "fdetect/RealDescriptor.hpp"

namespace jafar {
  namespace fdetect_v2 {
//fdetect_v2::InterestFeature<fdetect_v2::FloatDescriptor>
    template< typename InterestFeatureT >
    class SIFTDetectorT :  public fdetect_v2::Detector< InterestFeatureT > {
    public:
      typedef InterestFeatureT InterestFeatureType;
      typedef fdetect_v2::DetectionResult<InterestFeatureT> DetectionResult;

      SIFTDetectorT(double threshold = 0.04,
                    double edgeThreshold = 10,
                    double magnification = 3,
                    bool isNormalize = true,
                    bool recalculateAngles = true,
                    int nOctaves = cv::SIFT::CommonParams::DEFAULT_NOCTAVES,
                    int nOctaveLayers = cv::SIFT::CommonParams::DEFAULT_NOCTAVE_LAYERS,
                    int firstOctave = cv::SIFT::CommonParams::DEFAULT_FIRST_OCTAVE,
                    int angleMode = cv::SIFT::CommonParams::FIRST_ANGLE);
      // getters  //
      double getThreshold() const { return m_threshold; }
      double getEdgeThreshold() const { return m_edgeThreshold; }
      double getMagnification() const { return m_magnification; }
      bool getIsNormalize() const { return m_isNormalize; }
      bool getRecalculateAngles() const { return m_recalculateAngles; }
      int getNOctaves() const { return m_nOctaves; }
      int getNOctaveLayers() const { return m_nOctaveLayers; }
      int getFirstOctave() const { return m_firstOctave; }
      int getAngleMode() const { return m_angleMode; }
      // setters  //
      void setThreshold(double threshold) { m_threshold = threshold; }
      void setEdgeThreshold(double edgeThreshold) { m_edgeThreshold = edgeThreshold; }
      void setMagnification(double magnification) { m_magnification = magnification; }
      void setIsNormalize(bool isNormalize) { m_isNormalize = isNormalize; }
      void setRecalculateAngles(bool recalculateAngles) { m_recalculateAngles = recalculateAngles; }
      void setNOctaves(int nOctaves) { m_nOctaves = nOctaves; }
      void setNOctaveLayers(int nOctaveLayers) { m_nOctaveLayers = nOctaveLayers; }
      void setFirstOctave(int firstOctave) { m_firstOctave = firstOctave; }
      void setAngleMode(int angleMode) { m_angleMode = angleMode; }
      
      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);
    private:
      double m_threshold;
      double m_edgeThreshold;
      double m_magnification;
      bool m_isNormalize;
      bool m_recalculateAngles;
      int m_nOctaves;
      int m_nOctaveLayers;
      int m_firstOctave;
      int m_angleMode;
      cv::SIFT cv_sift;
      friend class boost::serialization::access;
      template<class Archive>
      void serialize(Archive & ar, const unsigned int /* file_version */){
        ar & m_threshold;
        ar & m_edgeThreshold;
        ar & m_magnification;
        ar & m_isNormalize;
        ar & m_recalculateAngles;
        ar & m_nOctaves;
        ar & m_nOctaveLayers;
        ar & m_firstOctave;
        ar & m_angleMode;
      }
    };
    typedef SIFTDetectorT<fdetect_v2::InterestFeature< fdetect_v2::RealDescriptor<float> > > SIFTDetector;
  }
}
#include "fdetect/SIFTDetector.hxx"
#endif
#endif
#endif