Merge pull request #2673 from BloodAxe:kaze

modules/features2d/doc/feature_detection_and_description.rst

@@ -249,3 +249,54 @@ We notice that for keypoint matching applications, image content has little effe
     :param keypoints: Set of detected keypoints
     :param corrThresh: Correlation threshold.
     :param verbose: Prints pair selection informations.
+
+KAZE
+----
+.. ocv:class:: KAZE : public Feature2D
+
+Class implementing the KAZE keypoint detector and descriptor extractor, described in [ABD12]_.
+
+.. [ABD12] KAZE Features. Pablo F. Alcantarilla, Adrien Bartoli and Andrew J. Davison. In European Conference on Computer Vision (ECCV), Fiorenze, Italy, October 2012.
+
+KAZE::KAZE
+----------
+The KAZE constructor
+
+.. ocv:function:: KAZE::KAZE(bool extended, bool upright)
+
+    :param extended: Set to enable extraction of extended (128-byte) descriptor.
+    :param upright: Set to enable use of upright descriptors (non rotation-invariant).
+
+
+
+AKAZE
+-----
+.. ocv:class:: AKAZE : public Feature2D
+
+Class implementing the AKAZE keypoint detector and descriptor extractor, described in [ANB13]_. ::
+
+    class CV_EXPORTS_W AKAZE : public Feature2D
+    {
+    public:
+        /// AKAZE Descriptor Type
+        enum DESCRIPTOR_TYPE {
+            DESCRIPTOR_KAZE_UPRIGHT = 2, ///< Upright descriptors, not invariant to rotation
+            DESCRIPTOR_KAZE = 3,
+            DESCRIPTOR_MLDB_UPRIGHT = 4, ///< Upright descriptors, not invariant to rotation
+            DESCRIPTOR_MLDB = 5
+        };
+        CV_WRAP AKAZE();
+        explicit AKAZE(DESCRIPTOR_TYPE descriptor_type, int descriptor_size = 0, int descriptor_channels = 3);
+    };
+
+.. [ANB13] Fast Explicit Diffusion for Accelerated Features in Nonlinear Scale Spaces. Pablo F. Alcantarilla, Jesús Nuevo and Adrien Bartoli. In British Machine Vision Conference (BMVC), Bristol, UK, September 2013.
+
+AKAZE::AKAZE
+------------
+The AKAZE constructor
+
+.. ocv:function:: AKAZE::AKAZE(DESCRIPTOR_TYPE descriptor_type, int descriptor_size = 0, int descriptor_channels = 3)
+
+    :param descriptor_type: Type of the extracted descriptor.
+    :param descriptor_size: Size of the descriptor in bits. 0 -> Full size
+    :param descriptor_channels: Number of channels in the descriptor (1, 2, 3).

modules/features2d/include/opencv2/features2d.hpp

@@ -895,7 +895,87 @@ protected:
     PixelTestFn test_fn_;
 };
 
+/*!
+KAZE implementation
+*/
+class CV_EXPORTS_W KAZE : public Feature2D
+{
+public:
+    CV_WRAP KAZE();
+    CV_WRAP explicit KAZE(bool extended, bool upright);
+
+    virtual ~KAZE();
+
+    // returns the descriptor size in bytes
+    int descriptorSize() const;
+    // returns the descriptor type
+    int descriptorType() const;
+    // returns the default norm type
+    int defaultNorm() const;
+
+    AlgorithmInfo* info() const;
+
+    // Compute the KAZE features on an image
+    void operator()(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints) const;
+
+    // Compute the KAZE features and descriptors on an image
+    void operator()(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints,
+        OutputArray descriptors, bool useProvidedKeypoints = false) const;
+
+protected:
+    void detectImpl(InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask) const;
+    void computeImpl(InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors) const;
+
+    CV_PROP int  descriptor;
+    CV_PROP bool extended;
+    CV_PROP bool upright;
+};
+
+/*!
+AKAZE implementation
+*/
+class CV_EXPORTS_W AKAZE : public Feature2D
+{
+public:
+    /// AKAZE Descriptor Type
+    enum DESCRIPTOR_TYPE {
+        DESCRIPTOR_KAZE_UPRIGHT = 2, ///< Upright descriptors, not invariant to rotation
+        DESCRIPTOR_KAZE = 3,
+        DESCRIPTOR_MLDB_UPRIGHT = 4, ///< Upright descriptors, not invariant to rotation
+        DESCRIPTOR_MLDB = 5
+    };
+
+    CV_WRAP AKAZE();
+    explicit AKAZE(DESCRIPTOR_TYPE descriptor_type, int descriptor_size = 0, int descriptor_channels = 3);
+
+    virtual ~AKAZE();
 
+    // returns the descriptor size in bytes
+    int descriptorSize() const;
+    // returns the descriptor type
+    int descriptorType() const;
+    // returns the default norm type
+    int defaultNorm() const;
+
+    // Compute the AKAZE features on an image
+    void operator()(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints) const;
+
+    // Compute the AKAZE features and descriptors on an image
+    void operator()(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints,
+        OutputArray descriptors, bool useProvidedKeypoints = false) const;
+
+    AlgorithmInfo* info() const;
+
+protected:
+
+    void computeImpl(InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors) const;
+    void detectImpl(InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask = noArray()) const;
+
+    CV_PROP int descriptor;
+    CV_PROP int descriptor_channels;
+    CV_PROP int descriptor_size;
+
+};
 /****************************************************************************************\
 *                                      Distance                                          *
 \****************************************************************************************/

modules/features2d/src/akaze.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2008, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/*
+OpenCV wrapper of reference implementation of
+[1] Fast Explicit Diffusion for Accelerated Features in Nonlinear Scale Spaces.
+Pablo F. Alcantarilla, J. Nuevo and Adrien Bartoli.
+In British Machine Vision Conference (BMVC), Bristol, UK, September 2013
+http://www.robesafe.com/personal/pablo.alcantarilla/papers/Alcantarilla13bmvc.pdf
+@author Eugene Khvedchenya <ekhvedchenya@gmail.com>
+*/
+
+#include "precomp.hpp"
+#include "akaze/AKAZEFeatures.h"
+
+namespace cv
+{
+    AKAZE::AKAZE()
+        : descriptor(DESCRIPTOR_MLDB)
+        , descriptor_channels(3)
+        , descriptor_size(0)
+    {
+    }
+
+    AKAZE::AKAZE(DESCRIPTOR_TYPE _descriptor_type, int _descriptor_size, int _descriptor_channels)
+        : descriptor(_descriptor_type)
+        , descriptor_channels(_descriptor_channels)
+        , descriptor_size(_descriptor_size)
+    {
+
+    }
+
+    AKAZE::~AKAZE()
+    {
+
+    }
+
+    // returns the descriptor size in bytes
+    int AKAZE::descriptorSize() const
+    {
+        switch (descriptor)
+        {
+        case cv::AKAZE::DESCRIPTOR_KAZE:
+        case cv::AKAZE::DESCRIPTOR_KAZE_UPRIGHT:
+            return 64;
+
+        case cv::AKAZE::DESCRIPTOR_MLDB:
+        case cv::AKAZE::DESCRIPTOR_MLDB_UPRIGHT:
+            // We use the full length binary descriptor -> 486 bits
+            if (descriptor_size == 0)
+            {
+                int t = (6 + 36 + 120) * descriptor_channels;
+                return (int)ceil(t / 8.);
+            }
+            else
+            {
+                // We use the random bit selection length binary descriptor
+                return (int)ceil(descriptor_size / 8.);
+            }
+
+        default:
+            return -1;
+        }
+    }
+
+    // returns the descriptor type
+    int AKAZE::descriptorType() const
+    {
+        switch (descriptor)
+        {
+        case cv::AKAZE::DESCRIPTOR_KAZE:
+        case cv::AKAZE::DESCRIPTOR_KAZE_UPRIGHT:
+                return CV_32F;
+
+        case cv::AKAZE::DESCRIPTOR_MLDB:
+        case cv::AKAZE::DESCRIPTOR_MLDB_UPRIGHT:
+                return CV_8U;
+
+            default:
+                return -1;
+        }
+    }
+
+    // returns the default norm type
+    int AKAZE::defaultNorm() const
+    {
+        switch (descriptor)
+        {
+        case cv::AKAZE::DESCRIPTOR_KAZE:
+        case cv::AKAZE::DESCRIPTOR_KAZE_UPRIGHT:
+            return cv::NORM_L2;
+
+        case cv::AKAZE::DESCRIPTOR_MLDB:
+        case cv::AKAZE::DESCRIPTOR_MLDB_UPRIGHT:
+            return cv::NORM_HAMMING;
+
+        default:
+            return -1;
+        }
+    }
+
+
+    void AKAZE::operator()(InputArray image, InputArray mask,
+        std::vector<KeyPoint>& keypoints,
+        OutputArray descriptors,
+        bool useProvidedKeypoints) const
+    {
+        cv::Mat img = image.getMat();
+        if (img.type() != CV_8UC1)
+            cvtColor(image, img, COLOR_BGR2GRAY);
+
+        Mat img1_32;
+        img.convertTo(img1_32, CV_32F, 1.0 / 255.0, 0);
+
+        cv::Mat& desc = descriptors.getMatRef();
+
+        AKAZEOptions options;
+        options.descriptor = static_cast<DESCRIPTOR_TYPE>(descriptor);
+        options.descriptor_channels = descriptor_channels;
+        options.descriptor_size = descriptor_size;
+        options.img_width = img.cols;
+        options.img_height = img.rows;
+
+        AKAZEFeatures impl(options);
+        impl.Create_Nonlinear_Scale_Space(img1_32);
+
+        if (!useProvidedKeypoints)
+        {
+            impl.Feature_Detection(keypoints);
+        }
+
+        if (!mask.empty())
+        {
+            cv::KeyPointsFilter::runByPixelsMask(keypoints, mask.getMat());
+        }
+
+        impl.Compute_Descriptors(keypoints, desc);
+
+        CV_Assert((!desc.rows || desc.cols == descriptorSize()));
+        CV_Assert((!desc.rows || (desc.type() == descriptorType())));
+    }
+
+    void AKAZE::detectImpl(InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask) const
+    {
+        cv::Mat img = image.getMat();
+        if (img.type() != CV_8UC1)
+            cvtColor(image, img, COLOR_BGR2GRAY);
+
+        Mat img1_32;
+        img.convertTo(img1_32, CV_32F, 1.0 / 255.0, 0);
+
+        AKAZEOptions options;
+        options.descriptor = static_cast<DESCRIPTOR_TYPE>(descriptor);
+        options.descriptor_channels = descriptor_channels;
+        options.descriptor_size = descriptor_size;
+        options.img_width = img.cols;
+        options.img_height = img.rows;
+
+        AKAZEFeatures impl(options);
+        impl.Create_Nonlinear_Scale_Space(img1_32);
+        impl.Feature_Detection(keypoints);
+
+        if (!mask.empty())
+        {
+            cv::KeyPointsFilter::runByPixelsMask(keypoints, mask.getMat());
+        }
+    }
+
+    void AKAZE::computeImpl(InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors) const
+    {
+        cv::Mat img = image.getMat();
+        if (img.type() != CV_8UC1)
+            cvtColor(image, img, COLOR_BGR2GRAY);
+
+        Mat img1_32;
+        img.convertTo(img1_32, CV_32F, 1.0 / 255.0, 0);
+
+        cv::Mat& desc = descriptors.getMatRef();
+
+        AKAZEOptions options;
+        options.descriptor = static_cast<DESCRIPTOR_TYPE>(descriptor);
+        options.descriptor_channels = descriptor_channels;
+        options.descriptor_size = descriptor_size;
+        options.img_width = img.cols;
+        options.img_height = img.rows;
+
+        AKAZEFeatures impl(options);
+        impl.Create_Nonlinear_Scale_Space(img1_32);
+        impl.Compute_Descriptors(keypoints, desc);
+
+        CV_Assert((!desc.rows || desc.cols == descriptorSize()));
+        CV_Assert((!desc.rows || (desc.type() == descriptorType())));
+    }
+}
\ No newline at end of file

modules/features2d/src/akaze/AKAZEConfig.h

+/**
+ * @file AKAZEConfig.h
+ * @brief AKAZE configuration file
+ * @date Feb 23, 2014
+ * @author Pablo F. Alcantarilla, Jesus Nuevo
+ */
+
+#pragma once
+
+/* ************************************************************************* */
+// OpenCV
+#include "precomp.hpp"
+#include <opencv2/features2d.hpp>
+
+/* ************************************************************************* */
+/// Lookup table for 2d gaussian (sigma = 2.5) where (0,0) is top left and (6,6) is bottom right
+const float gauss25[7][7] = {
+    { 0.02546481f, 0.02350698f, 0.01849125f, 0.01239505f, 0.00708017f, 0.00344629f, 0.00142946f },
+    { 0.02350698f, 0.02169968f, 0.01706957f, 0.01144208f, 0.00653582f, 0.00318132f, 0.00131956f },
+    { 0.01849125f, 0.01706957f, 0.01342740f, 0.00900066f, 0.00514126f, 0.00250252f, 0.00103800f },
+    { 0.01239505f, 0.01144208f, 0.00900066f, 0.00603332f, 0.00344629f, 0.00167749f, 0.00069579f },
+    { 0.00708017f, 0.00653582f, 0.00514126f, 0.00344629f, 0.00196855f, 0.00095820f, 0.00039744f },
+    { 0.00344629f, 0.00318132f, 0.00250252f, 0.00167749f, 0.00095820f, 0.00046640f, 0.00019346f },
+    { 0.00142946f, 0.00131956f, 0.00103800f, 0.00069579f, 0.00039744f, 0.00019346f, 0.00008024f }
+};
+
+/* ************************************************************************* */
+/// AKAZE configuration options structure
+struct AKAZEOptions {
+
+    /// AKAZE Diffusivities
+    enum DIFFUSIVITY_TYPE {
+        PM_G1 = 0,
+        PM_G2 = 1,
+        WEICKERT = 2,
+        CHARBONNIER = 3
+    };
+
+    AKAZEOptions()
+        : omax(4)
+        , nsublevels(4)
+        , img_width(0)
+        , img_height(0)
+        , soffset(1.6f)
+        , derivative_factor(1.5f)
+        , sderivatives(1.0)
+        , diffusivity(PM_G2)
+
+        , dthreshold(0.001f)
+        , min_dthreshold(0.00001f)
+
+        , descriptor(cv::AKAZE::DESCRIPTOR_MLDB)
+        , descriptor_size(0)
+        , descriptor_channels(3)
+        , descriptor_pattern_size(10)
+
+        , kcontrast(0.001f)
+        , kcontrast_percentile(0.7f)
+        , kcontrast_nbins(300)
+    {
+    }
+
+    int omax;                       ///< Maximum octave evolution of the image 2^sigma (coarsest scale sigma units)
+    int nsublevels;                 ///< Default number of sublevels per scale level
+    int img_width;                  ///< Width of the input image
+    int img_height;                 ///< Height of the input image
+    float soffset;                  ///< Base scale offset (sigma units)
+    float derivative_factor;        ///< Factor for the multiscale derivatives
+    float sderivatives;             ///< Smoothing factor for the derivatives
+    DIFFUSIVITY_TYPE diffusivity;   ///< Diffusivity type
+
+    float dthreshold;               ///< Detector response threshold to accept point
+    float min_dthreshold;           ///< Minimum detector threshold to accept a point
+
+    cv::AKAZE::DESCRIPTOR_TYPE descriptor;     ///< Type of descriptor
+    int descriptor_size;            ///< Size of the descriptor in bits. 0->Full size
+    int descriptor_channels;        ///< Number of channels in the descriptor (1, 2, 3)
+    int descriptor_pattern_size;    ///< Actual patch size is 2*pattern_size*point.scale
+
+    float kcontrast;                ///< The contrast factor parameter
+    float kcontrast_percentile;     ///< Percentile level for the contrast factor
+    int kcontrast_nbins;            ///< Number of bins for the contrast factor histogram
+};
+
+/* ************************************************************************* */
+/// AKAZE nonlinear diffusion filtering evolution
+struct TEvolution {
+
+    TEvolution() {
+        etime = 0.0f;
+        esigma = 0.0f;
+        octave = 0;
+        sublevel = 0;
+        sigma_size = 0;
+    }
+
+    cv::Mat Lx, Ly;	// First order spatial derivatives
+    cv::Mat Lxx, Lxy, Lyy;	// Second order spatial derivatives
+    cv::Mat Lflow;	// Diffusivity image
+    cv::Mat Lt;	// Evolution image
+    cv::Mat Lsmooth; // Smoothed image
+    cv::Mat Lstep; // Evolution step update
+    cv::Mat Ldet; // Detector response
+    float etime;	// Evolution time
+    float esigma;	// Evolution sigma. For linear diffusion t = sigma^2 / 2
+    size_t octave;	// Image octave
+    size_t sublevel;	// Image sublevel in each octave
+    size_t sigma_size;	// Integer sigma. For computing the feature detector responses
+};
\ No newline at end of file

modules/features2d/src/akaze/AKAZEFeatures.h

+/**
+ * @file AKAZE.h
+ * @brief Main class for detecting and computing binary descriptors in an
+ * accelerated nonlinear scale space
+ * @date Mar 27, 2013
+ * @author Pablo F. Alcantarilla, Jesus Nuevo
+ */
+
+#pragma once
+
+/* ************************************************************************* */
+// Includes
+#include "precomp.hpp"
+#include "AKAZEConfig.h"
+
+/* ************************************************************************* */
+// AKAZE Class Declaration
+class AKAZEFeatures {
+
+private:
+
+    AKAZEOptions options_;                ///< Configuration options for AKAZE
+    std::vector<TEvolution> evolution_;	///< Vector of nonlinear diffusion evolution
+
+    /// FED parameters
+    int ncycles_;                  ///< Number of cycles
+    bool reordering_;              ///< Flag for reordering time steps
+    std::vector<std::vector<float > > tsteps_;  ///< Vector of FED dynamic time steps
+    std::vector<int> nsteps_;      ///< Vector of number of steps per cycle
+
+    /// Matrices for the M-LDB descriptor computation
+    cv::Mat descriptorSamples_;  // List of positions in the grids to sample LDB bits from.
+    cv::Mat descriptorBits_;
+    cv::Mat bitMask_;
+
+public:
+
+    /// Constructor with input arguments
+    AKAZEFeatures(const AKAZEOptions& options);
+
+    /// Scale Space methods
+    void Allocate_Memory_Evolution();
+    int Create_Nonlinear_Scale_Space(const cv::Mat& img);
+    void Feature_Detection(std::vector<cv::KeyPoint>& kpts);
+    void Compute_Determinant_Hessian_Response(void);
+    void Compute_Multiscale_Derivatives(void);
+    void Find_Scale_Space_Extrema(std::vector<cv::KeyPoint>& kpts);
+    void Do_Subpixel_Refinement(std::vector<cv::KeyPoint>& kpts);
+
+    // Feature description methods
+    void Compute_Descriptors(std::vector<cv::KeyPoint>& kpts, cv::Mat& desc);
+
+    static void Compute_Main_Orientation(cv::KeyPoint& kpt, const std::vector<TEvolution>& evolution_);
+};
+
+/* ************************************************************************* */
+// Inline functions
+
+// Inline functions
+void generateDescriptorSubsample(cv::Mat& sampleList, cv::Mat& comparisons,
+    int nbits, int pattern_size, int nchannels);
+float get_angle(float x, float y);
+float gaussian(float x, float y, float sigma);
+void check_descriptor_limits(int& x, int& y, int width, int height);
+int fRound(float flt);

modules/features2d/src/features2d_init.cpp

@@ -125,6 +125,21 @@ CV_INIT_ALGORITHM(GFTTDetector, "Feature2D.GFTT",
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+CV_INIT_ALGORITHM(KAZE, "Feature2D.KAZE",
+                  obj.info()->addParam(obj, "upright", obj.upright);
+                  obj.info()->addParam(obj, "extended", obj.extended))
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+CV_INIT_ALGORITHM(AKAZE, "Feature2D.AKAZE",
+                  obj.info()->addParam(obj, "descriptor_channels", obj.descriptor_channels);
+                  obj.info()->addParam(obj, "descriptor", obj.descriptor);
+                  obj.info()->addParam(obj, "descriptor_size", obj.descriptor_size))
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
 CV_INIT_ALGORITHM(SimpleBlobDetector, "Feature2D.SimpleBlob",
                   obj.info()->addParam(obj, "thresholdStep",    obj.params.thresholdStep);
                   obj.info()->addParam(obj, "minThreshold",     obj.params.minThreshold);
@@ -202,11 +217,13 @@ bool cv::initModule_features2d(void)
     all &= !FREAK_info_auto.name().empty();
     all &= !ORB_info_auto.name().empty();
     all &= !GFTTDetector_info_auto.name().empty();
-    all &= !HarrisDetector_info_auto.name().empty();
+    all &= !KAZE_info_auto.name().empty();
+    all &= !AKAZE_info_auto.name().empty();
+        all &= !HarrisDetector_info_auto.name().empty();
     all &= !DenseFeatureDetector_info_auto.name().empty();
     all &= !GridAdaptedFeatureDetector_info_auto.name().empty();
     all &= !BFMatcher_info_auto.name().empty();
     all &= !FlannBasedMatcher_info_auto.name().empty();
 
     return all;
-}
+}
\ No newline at end of file

modules/features2d/src/kaze.cpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2008, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/*
+OpenCV wrapper of reference implementation of
+[1] KAZE Features. Pablo F. Alcantarilla, Adrien Bartoli and Andrew J. Davison.
+In European Conference on Computer Vision (ECCV), Fiorenze, Italy, October 2012
+http://www.robesafe.com/personal/pablo.alcantarilla/papers/Alcantarilla12eccv.pdf
+@author Eugene Khvedchenya <ekhvedchenya@gmail.com>
+*/
+
+#include "precomp.hpp"
+#include "kaze/KAZEFeatures.h"
+
+namespace cv
+{
+    KAZE::KAZE()
+        : extended(false)
+        , upright(false)
+    {
+    }
+
+    KAZE::KAZE(bool _extended, bool _upright)
+        : extended(_extended)
+        , upright(_upright)
+    {
+
+    }
+    KAZE::~KAZE()
+    {
+
+    }
+
+    // returns the descriptor size in bytes
+    int KAZE::descriptorSize() const
+    {
+        return extended ? 128 : 64;
+    }
+
+    // returns the descriptor type
+    int KAZE::descriptorType() const
+    {
+        return CV_32F;
+    }
+
+    // returns the default norm type
+    int KAZE::defaultNorm() const
+    {
+        return NORM_L2;
+    }
+
+    void KAZE::operator()(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints) const
+    {
+        detectImpl(image, keypoints, mask);
+    }
+
+    void KAZE::operator()(InputArray image, InputArray mask,
+        std::vector<KeyPoint>& keypoints,
+        OutputArray descriptors,
+        bool useProvidedKeypoints) const
+    {
+        cv::Mat img = image.getMat();
+        if (img.type() != CV_8UC1)
+            cvtColor(image, img, COLOR_BGR2GRAY);
+
+        Mat img1_32;
+        img.convertTo(img1_32, CV_32F, 1.0 / 255.0, 0);
+
+        cv::Mat& desc = descriptors.getMatRef();
+
+        KAZEOptions options;
+        options.img_width = img.cols;
+        options.img_height = img.rows;
+        options.extended = extended;
+        options.upright = upright;
+
+        KAZEFeatures impl(options);
+        impl.Create_Nonlinear_Scale_Space(img1_32);
+
+        if (!useProvidedKeypoints)
+        {
+            impl.Feature_Detection(keypoints);
+        }
+
+        if (!mask.empty())
+        {
+            cv::KeyPointsFilter::runByPixelsMask(keypoints, mask.getMat());
+        }
+
+        impl.Feature_Description(keypoints, desc);
+
+        CV_Assert((!desc.rows || desc.cols == descriptorSize()));
+        CV_Assert((!desc.rows || (desc.type() == descriptorType())));
+    }
+
+    void KAZE::detectImpl(InputArray image, std::vector<KeyPoint>& keypoints, InputArray mask) const
+    {
+        Mat img = image.getMat();
+        if (img.type() != CV_8UC1)
+            cvtColor(image, img, COLOR_BGR2GRAY);
+
+        Mat img1_32;
+        img.convertTo(img1_32, CV_32F, 1.0 / 255.0, 0);
+
+        KAZEOptions options;
+        options.img_width = img.cols;
+        options.img_height = img.rows;
+        options.extended = extended;
+        options.upright = upright;
+
+        KAZEFeatures impl(options);
+        impl.Create_Nonlinear_Scale_Space(img1_32);
+        impl.Feature_Detection(keypoints);
+
+        if (!mask.empty())
+        {
+            cv::KeyPointsFilter::runByPixelsMask(keypoints, mask.getMat());
+        }
+    }
+
+    void KAZE::computeImpl(InputArray image, std::vector<KeyPoint>& keypoints, OutputArray descriptors) const
+    {
+        cv::Mat img = image.getMat();
+        if (img.type() != CV_8UC1)
+            cvtColor(image, img, COLOR_BGR2GRAY);
+
+        Mat img1_32;
+        img.convertTo(img1_32, CV_32F, 1.0 / 255.0, 0);
+
+        cv::Mat& desc = descriptors.getMatRef();
+
+        KAZEOptions options;
+        options.img_width = img.cols;
+        options.img_height = img.rows;
+        options.extended = extended;
+        options.upright = upright;
+
+        KAZEFeatures impl(options);
+        impl.Create_Nonlinear_Scale_Space(img1_32);
+        impl.Feature_Description(keypoints, desc);
+
+        CV_Assert((!desc.rows || desc.cols == descriptorSize()));
+        CV_Assert((!desc.rows || (desc.type() == descriptorType())));
+    }
+}
\ No newline at end of file

modules/features2d/src/kaze/KAZEConfig.h

+/**
+ * @file KAZEConfig.h
+ * @brief Configuration file
+ * @date Dec 27, 2011
+ * @author Pablo F. Alcantarilla
+ */
+
+#pragma once
+
+// OpenCV Includes
+#include "precomp.hpp"
+#include <opencv2/features2d.hpp>
+
+//*************************************************************************************
+
+struct KAZEOptions {
+
+    enum DIFFUSIVITY_TYPE {
+        PM_G1 = 0,
+        PM_G2 = 1,
+        WEICKERT = 2
+    };
+
+    KAZEOptions()
+        : diffusivity(PM_G2)
+
+        , soffset(1.60f)
+        , omax(4)
+        , nsublevels(4)
+        , img_width(0)
+        , img_height(0)
+        , sderivatives(1.0f)
+        , dthreshold(0.001f)
+        , kcontrast(0.01f)
+        , kcontrast_percentille(0.7f)
+        , kcontrast_bins(300)
+
+        , use_fed(true)
+        , upright(false)
+        , extended(false)
+
+        , use_clipping_normalilzation(false)
+        , clipping_normalization_ratio(1.6f)
+        , clipping_normalization_niter(5)
+    {
+    }
+
+    DIFFUSIVITY_TYPE diffusivity;
+
+    float soffset;
+    int omax;
+    int nsublevels;
+    int img_width;
+    int img_height;
+    float sderivatives;
+    float dthreshold;
+    float kcontrast;
+    float kcontrast_percentille;
+    int  kcontrast_bins;
+
+    bool use_fed;
+    bool upright;
+    bool extended;
+
+    bool  use_clipping_normalilzation;
+    float clipping_normalization_ratio;
+    int   clipping_normalization_niter;
+};
+
+struct TEvolution {
+    cv::Mat Lx, Ly;	// First order spatial derivatives
+    cv::Mat Lxx, Lxy, Lyy;	// Second order spatial derivatives
+    cv::Mat Lflow;	// Diffusivity image
+    cv::Mat Lt;	// Evolution image
+    cv::Mat Lsmooth; // Smoothed image
+    cv::Mat Lstep; // Evolution step update
+    cv::Mat Ldet; // Detector response
+    float etime;	// Evolution time
+    float esigma;	// Evolution sigma. For linear diffusion t = sigma^2 / 2
+    float octave;	// Image octave
+    float sublevel;	// Image sublevel in each octave
+    int sigma_size;	// Integer esigma. For computing the feature detector responses
+};

modules/features2d/src/kaze/KAZEFeatures.h

+
+/**
+ * @file KAZE.h
+ * @brief Main program for detecting and computing descriptors in a nonlinear
+ * scale space
+ * @date Jan 21, 2012
+ * @author Pablo F. Alcantarilla
+ */
+
+#ifndef KAZE_H_
+#define KAZE_H_
+
+//*************************************************************************************
+//*************************************************************************************
+
+// Includes
+#include "KAZEConfig.h"
+#include "nldiffusion_functions.h"
+#include "fed.h"
+
+//*************************************************************************************
+//*************************************************************************************
+
+// KAZE Class Declaration
+class KAZEFeatures {
+
+private:
+
+    KAZEOptions options;
+
+    // Parameters of the Nonlinear diffusion class
+    std::vector<TEvolution> evolution_;	// Vector of nonlinear diffusion evolution
+
+    // Vector of keypoint vectors for finding extrema in multiple threads
+    std::vector<std::vector<cv::KeyPoint> > kpts_par_;
+
+    // FED parameters
+    int ncycles_;                  // Number of cycles
+    bool reordering_;              // Flag for reordering time steps
+    std::vector<std::vector<float > > tsteps_;  // Vector of FED dynamic time steps
+    std::vector<int> nsteps_;      // Vector of number of steps per cycle
+
+    // Some auxiliary variables used in the AOS step
+    cv::Mat Ltx_, Lty_, px_, py_, ax_, ay_, bx_, by_, qr_, qc_;
+
+public:
+
+    // Constructor
+    KAZEFeatures(KAZEOptions& options);
+
+    // Public methods for KAZE interface
+    void Allocate_Memory_Evolution(void);
+    int Create_Nonlinear_Scale_Space(const cv::Mat& img);
+    void Feature_Detection(std::vector<cv::KeyPoint>& kpts);
+    void Feature_Description(std::vector<cv::KeyPoint>& kpts, cv::Mat& desc);
+
+    static void Compute_Main_Orientation(cv::KeyPoint& kpt, const std::vector<TEvolution>& evolution_, const KAZEOptions& options);
+
+private:
+
+    // Feature Detection Methods
+    void Compute_KContrast(const cv::Mat& img, const float& kper);
+    void Compute_Multiscale_Derivatives(void);
+    void Compute_Detector_Response(void);
+    void Determinant_Hessian_Parallel(std::vector<cv::KeyPoint>& kpts);
+    void Find_Extremum_Threading(const int& level);
+    void Do_Subpixel_Refinement(std::vector<cv::KeyPoint>& kpts);
+
+    // AOS Methods
+    void AOS_Step_Scalar(cv::Mat &Ld, const cv::Mat &Ldprev, const cv::Mat &c, const float& stepsize);
+    void AOS_Rows(const cv::Mat &Ldprev, const cv::Mat &c, const float& stepsize);
+    void AOS_Columns(const cv::Mat &Ldprev, const cv::Mat &c, const float& stepsize);
+    void Thomas(const cv::Mat &a, const cv::Mat &b, const cv::Mat &Ld, cv::Mat &x);
+
+};
+
+//*************************************************************************************
+//*************************************************************************************
+
+// Inline functions
+float getAngle(const float& x, const float& y);
+float gaussian(const float& x, const float& y, const float& sig);
+void checkDescriptorLimits(int &x, int &y, const int& width, const int& height);
+void clippingDescriptor(float *desc, const int& dsize, const int& niter, const float& ratio);
+int fRound(const float& flt);
+
+//*************************************************************************************
+//*************************************************************************************
+
+#endif // KAZE_H_

modules/features2d/src/kaze/fed.cpp

+//=============================================================================
+//
+// fed.cpp
+// Authors: Pablo F. Alcantarilla (1), Jesus Nuevo (2)
+// Institutions: Georgia Institute of Technology (1)
+//               TrueVision Solutions (2)
+// Date: 15/09/2013
+// Email: pablofdezalc@gmail.com
+//
+// AKAZE Features Copyright 2013, Pablo F. Alcantarilla, Jesus Nuevo
+// All Rights Reserved
+// See LICENSE for the license information
+//=============================================================================
+
+/**
+ * @file fed.cpp
+ * @brief Functions for performing Fast Explicit Diffusion and building the
+ * nonlinear scale space
+ * @date Sep 15, 2013
+ * @author Pablo F. Alcantarilla, Jesus Nuevo
+ * @note This code is derived from FED/FJ library from Grewenig et al.,
+ * The FED/FJ library allows solving more advanced problems
+ * Please look at the following papers for more information about FED:
+ * [1] S. Grewenig, J. Weickert, C. Schroers, A. Bruhn. Cyclic Schemes for
+ * PDE-Based Image Analysis. Technical Report No. 327, Department of Mathematics,
+ * Saarland University, Saarbrücken, Germany, March 2013
+ * [2] S. Grewenig, J. Weickert, A. Bruhn. From box filtering to fast explicit diffusion.
+ * DAGM, 2010
+ *
+*/
+#include "precomp.hpp"
+#include "fed.h"
+
+using namespace std;
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function allocates an array of the least number of time steps such
+ * that a certain stopping time for the whole process can be obtained and fills
+ * it with the respective FED time step sizes for one cycle
+ * The function returns the number of time steps per cycle or 0 on failure
+ * @param T Desired process stopping time
+ * @param M Desired number of cycles
+ * @param tau_max Stability limit for the explicit scheme
+ * @param reordering Reordering flag
+ * @param tau The vector with the dynamic step sizes
+ */
+int fed_tau_by_process_time(const float& T, const int& M, const float& tau_max,
+                            const bool& reordering, std::vector<float>& tau) {
+  // All cycles have the same fraction of the stopping time
+  return fed_tau_by_cycle_time(T/(float)M,tau_max,reordering,tau);
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function allocates an array of the least number of time steps such
+ * that a certain stopping time for the whole process can be obtained and fills it
+ * it with the respective FED time step sizes for one cycle
+ * The function returns the number of time steps per cycle or 0 on failure
+ * @param t Desired cycle stopping time
+ * @param tau_max Stability limit for the explicit scheme
+ * @param reordering Reordering flag
+ * @param tau The vector with the dynamic step sizes
+ */
+int fed_tau_by_cycle_time(const float& t, const float& tau_max,
+                          const bool& reordering, std::vector<float> &tau) {
+  int n = 0;          // Number of time steps
+  float scale = 0.0;  // Ratio of t we search to maximal t
+
+  // Compute necessary number of time steps
+  n = (int)(ceilf(sqrtf(3.0f*t/tau_max+0.25f)-0.5f-1.0e-8f)+ 0.5f);
+  scale = 3.0f*t/(tau_max*(float)(n*(n+1)));
+
+  // Call internal FED time step creation routine
+  return fed_tau_internal(n,scale,tau_max,reordering,tau);
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function allocates an array of time steps and fills it with FED
+ * time step sizes
+ * The function returns the number of time steps per cycle or 0 on failure
+ * @param n Number of internal steps
+ * @param scale Ratio of t we search to maximal t
+ * @param tau_max Stability limit for the explicit scheme
+ * @param reordering Reordering flag
+ * @param tau The vector with the dynamic step sizes
+ */
+int fed_tau_internal(const int& n, const float& scale, const float& tau_max,
+                     const bool& reordering, std::vector<float> &tau) {
+  float c = 0.0, d = 0.0;     // Time savers
+  vector<float> tauh;    // Helper vector for unsorted taus
+
+  if (n <= 0) {
+    return 0;
+  }
+
+  // Allocate memory for the time step size
+  tau = vector<float>(n);
+
+  if (reordering) {
+    tauh = vector<float>(n);
+  }
+
+  // Compute time saver
+  c = 1.0f / (4.0f * (float)n + 2.0f);
+  d = scale * tau_max / 2.0f;
+
+  // Set up originally ordered tau vector
+  for (int k = 0; k < n; ++k) {
+    float h = cosf((float)CV_PI * (2.0f * (float)k + 1.0f) * c);
+
+    if (reordering) {
+      tauh[k] = d / (h * h);
+    }
+    else {
+      tau[k] = d / (h * h);
+    }
+  }
+
+  // Permute list of time steps according to chosen reordering function
+  int kappa = 0, prime = 0;
+
+  if (reordering == true) {
+    // Choose kappa cycle with k = n/2
+    // This is a heuristic. We can use Leja ordering instead!!
+    kappa = n / 2;
+
+    // Get modulus for permutation
+    prime = n + 1;
+
+    while (!fed_is_prime_internal(prime)) {
+      prime++;
+    }
+
+    // Perform permutation
+    for (int k = 0, l = 0; l < n; ++k, ++l) {
+      int index = 0;
+      while ((index = ((k+1)*kappa) % prime - 1) >= n) {
+        k++;
+      }
+
+      tau[l] = tauh[index];
+    }
+  }
+
+  return n;
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function checks if a number is prime or not
+ * @param number Number to check if it is prime or not
+ * @return true if the number is prime
+ */
+bool fed_is_prime_internal(const int& number) {
+  bool is_prime = false;
+
+  if (number <= 1) {
+    return false;
+  }
+  else if (number == 1 || number == 2 || number == 3 || number == 5 || number == 7) {
+    return true;
+  }
+  else if ((number % 2) == 0 || (number % 3) == 0 || (number % 5) == 0 || (number % 7) == 0) {
+    return false;
+  }
+  else {
+    is_prime = true;
+    int upperLimit = (int)sqrt(1.0f + number);
+    int divisor = 11;
+
+    while (divisor <= upperLimit ) {
+      if (number % divisor == 0)
+      {
+        is_prime = false;
+      }
+
+      divisor +=2;
+    }
+
+    return is_prime;
+  }
+}

modules/features2d/src/kaze/fed.h

+#ifndef FED_H
+#define FED_H
+
+//******************************************************************************
+//******************************************************************************
+
+// Includes
+#include <vector>
+
+//*************************************************************************************
+//*************************************************************************************
+
+// Declaration of functions
+int fed_tau_by_process_time(const float& T, const int& M, const float& tau_max,
+                            const bool& reordering, std::vector<float>& tau);
+int fed_tau_by_cycle_time(const float& t, const float& tau_max,
+                          const bool& reordering, std::vector<float> &tau) ;
+int fed_tau_internal(const int& n, const float& scale, const float& tau_max,
+                     const bool& reordering, std::vector<float> &tau);
+bool fed_is_prime_internal(const int& number);
+
+//*************************************************************************************
+//*************************************************************************************
+
+#endif // FED_H

modules/features2d/src/kaze/nldiffusion_functions.h

+/**
+ * @file nldiffusion_functions.h
+ * @brief Functions for non-linear diffusion applications:
+ * 2D Gaussian Derivatives
+ * Perona and Malik conductivity equations
+ * Perona and Malik evolution
+ * @date Dec 27, 2011
+ * @author Pablo F. Alcantarilla
+ */
+
+#ifndef KAZE_NLDIFFUSION_FUNCTIONS_H
+#define KAZE_NLDIFFUSION_FUNCTIONS_H
+
+/* ************************************************************************* */
+// Includes
+#include "precomp.hpp"
+
+/* ************************************************************************* */
+// Declaration of functions
+
+namespace cv {
+    namespace details {
+        namespace kaze {
+
+            // Gaussian 2D convolution
+            void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, int ksize_x, int ksize_y, float sigma);
+
+            // Diffusivity functions
+            void pm_g1(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, float k);
+            void pm_g2(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, float k);
+            void weickert_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, float k);
+            void charbonnier_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, float k);
+
+            float compute_k_percentile(const cv::Mat& img, float perc, float gscale, int nbins, int ksize_x, int ksize_y);
+
+            // Image derivatives
+            void compute_scharr_derivatives(const cv::Mat& src, cv::Mat& dst, int xorder, int yorder, int scale);
+            void compute_derivative_kernels(cv::OutputArray _kx, cv::OutputArray _ky, int dx, int dy, int scale);
+            void image_derivatives_scharr(const cv::Mat& src, cv::Mat& dst, int xorder, int yorder);
+
+            // Nonlinear diffusion filtering scalar step
+            void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsize);
+
+            // For non-maxima suppresion
+            bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value, int row, int col, bool same_img);
+
+            // Image downsampling
+            void halfsample_image(const cv::Mat& src, cv::Mat& dst);
+        }
+    }
+}
+
+#endif

modules/features2d/test/test_keypoints.cpp

@@ -166,3 +166,18 @@ TEST(Features2d_Detector_Keypoints_Dense, validation)
     CV_FeatureDetectorKeypointsTest test(Algorithm::create<FeatureDetector>("Feature2D.Dense"));
     test.safe_run();
 }
+
+TEST(Features2d_Detector_Keypoints_KAZE, validation)
+{
+    CV_FeatureDetectorKeypointsTest test(Algorithm::create<FeatureDetector>("Feature2D.KAZE"));
+    test.safe_run();
+}
+
+TEST(Features2d_Detector_Keypoints_AKAZE, validation)
+{
+    CV_FeatureDetectorKeypointsTest test_kaze(cv::Ptr<FeatureDetector>(new cv::AKAZE(cv::AKAZE::DESCRIPTOR_KAZE)));
+    test_kaze.safe_run();
+
+    CV_FeatureDetectorKeypointsTest test_mldb(cv::Ptr<FeatureDetector>(new cv::AKAZE(cv::AKAZE::DESCRIPTOR_MLDB)));
+    test_mldb.safe_run();
+}

modules/features2d/test/test_rotation_and_scale_invariance.cpp

@@ -652,6 +652,21 @@ TEST(Features2d_ScaleInvariance_Detector_BRISK, regression)
     test.safe_run();
 }
 
+TEST(Features2d_ScaleInvariance_Detector_KAZE, regression)
+{
+    DetectorScaleInvarianceTest test(Algorithm::create<FeatureDetector>("Feature2D.KAZE"),
+        0.08f,
+        0.49f);
+    test.safe_run();
+}
+
+TEST(Features2d_ScaleInvariance_Detector_AKAZE, regression)
+{
+    DetectorScaleInvarianceTest test(Algorithm::create<FeatureDetector>("Feature2D.AKAZE"),
+        0.08f,
+        0.49f);
+    test.safe_run();
+}
 //TEST(Features2d_ScaleInvariance_Detector_ORB, regression)
 //{
 //    DetectorScaleInvarianceTest test(Algorithm::create<FeatureDetector>("Feature2D.ORB"),