added FREAK (by Kirell Benzi, Raphael Ortiz, Alexandre Alahi and Pierre Vandergheynst)

modules/features2d/include/opencv2/features2d/features2d.hpp

@@ -310,6 +310,95 @@ protected:
 typedef ORB OrbFeatureDetector;
 typedef ORB OrbDescriptorExtractor;
 
+/*!
+  FREAK implementation
+*/
+class CV_EXPORTS FREAK : public DescriptorExtractor
+{
+public:
+    /** Constructor
+         * @param orientationNormalized enable orientation normalization
+         * @param scaleNormalized enable scale normalization
+         * @param patternScale scaling of the description pattern
+         * @param nbOctave number of octaves covered by the detected keypoints
+         * @param selectedPairs (optional) user defined selected pairs
+    */
+    explicit FREAK( bool orientationNormalized = true,
+           bool scaleNormalized = true,
+           float patternScale = 22.0f,
+           int nOctaves = 4,
+           const vector<int>& selectedPairs = vector<int>());
+	FREAK( const FREAK& rhs );
+    FREAK& operator=( const FREAK& );
+
+    virtual ~FREAK();
+
+    /** returns the descriptor length in bytes */
+    virtual int descriptorSize() const;
+
+    /** returns the descriptor type */
+    virtual int descriptorType() const;
+
+    /** select the 512 "best description pairs"
+         * @param images grayscale images set
+         * @param keypoints set of detected keypoints
+         * @param corrThresh correlation threshold
+         * @param verbose print construction information
+         * @return list of best pair indexes
+    */
+    vector<int> selectPairs( const vector<Mat>& images, vector<vector<KeyPoint> >& keypoints,
+                      const double corrThresh = 0.7, bool verbose = true );
+
+	AlgorithmInfo* info() const;
+
+	enum
+	{
+		NB_SCALES = 64, NB_PAIRS = 512, NB_ORIENPAIRS = 45
+	};
+
+protected:
+    virtual void computeImpl( const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptors ) const;
+	void buildPattern();
+	uchar meanIntensity( const Mat& image, const Mat& integral, const float kp_x, const float kp_y,
+                         const unsigned int scale, const unsigned int rot, const unsigned int point ) const;
+
+	bool orientationNormalized; //true if the orientation is normalized, false otherwise
+    bool scaleNormalized; //true if the scale is normalized, false otherwise
+    double patternScale; //scaling of the pattern
+    int nOctaves; //number of octaves
+    bool extAll; // true if all pairs need to be extracted for pairs selection
+    
+    double patternScale0;
+    int nOctaves0;
+    vector<int> selectedPairs0;
+
+	struct PatternPoint
+	{
+	    float x; // x coordinate relative to center
+	    float y; // x coordinate relative to center
+	    float sigma; // Gaussian smoothing sigma
+	};
+
+	struct DescriptionPair
+	{
+	    uchar i; // index of the first point
+	    uchar j; // index of the second point
+	};
+
+	struct OrientationPair
+	{
+	    uchar i; // index of the first point
+	    uchar j; // index of the second point
+	    int weight_dx; // dx/(norm_sq))*4096
+	    int weight_dy; // dy/(norm_sq))*4096
+	};
+	
+	vector<PatternPoint> patternLookup; // look-up table for the pattern points (position+sigma of all points at all scales and orientation)
+    int patternSizes[NB_SCALES]; // size of the pattern at a specific scale (used to check if a point is within image boundaries)
+    DescriptionPair descriptionPairs[NB_PAIRS];
+    OrientationPair orientationPairs[NB_ORIENPAIRS];
+};
+
 
 /*!
  Maximal Stable Extremal Regions class.
@@ -464,7 +553,7 @@ protected:
   };
 
   virtual void detectImpl( const Mat& image, vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const;
-  virtual void findBlobs(const cv::Mat &image, const cv::Mat &binaryImage, std::vector<Center> &centers) const;
+  virtual void findBlobs(const Mat &image, const Mat &binaryImage, vector<Center> &centers) const;
 
   Params params;
 };