KAZE and AKAZE integration initial commit

modules/features2d/src/kaze/KAZE.h

@@ -0,0 +1,294 @@
+
+/**
+ * @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 "config.h"
+#include "nldiffusion_functions.h"
+#include "fed.h"
+#include "utils.h"
+
+//*************************************************************************************
+//*************************************************************************************
+
+// KAZE Class Declaration
+class KAZE {
+
+private:
+
+  // Parameters of the Nonlinear diffusion class
+  float soffset_;	// Base scale offset
+  float sderivatives_; // Standard deviation of the Gaussian for the nonlinear diff. derivatives
+  int omax_;		// Maximum octave level
+  int nsublevels_;	// Number of sublevels per octave level
+  int img_width_;	// Width of the original image
+  int img_height_; // Height of the original image
+  bool save_scale_space_; // For saving scale space images
+  bool verbosity_;	// Verbosity level
+  std::vector<TEvolution> evolution_;	// Vector of nonlinear diffusion evolution
+  float kcontrast_; // The contrast parameter for the scalar nonlinear diffusion
+  float dthreshold_;	// Feature detector threshold response
+  int diffusivity_; 	// Diffusivity type, 0->PM G1, 1->PM G2, 2-> Weickert
+  int descriptor_mode_; // Descriptor mode
+  bool use_fed_;        // Set to true in case we want to use FED for the nonlinear diffusion filtering. Set false for using AOS
+  bool use_upright_;	// Set to true in case we want to use the upright version of the descriptors
+  bool use_extended_;	// Set to true in case we want to use the extended version of the descriptors
+
+  // 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
+
+  // Computation times variables in ms
+  double tkcontrast_;       // Kcontrast factor computation
+  double tnlscale_;         // Nonlinear Scale space generation
+  double tdetector_;        // Feature detector
+  double tmderivatives_;    // Multiscale derivatives computation
+  double tdresponse_;       // Detector response computation
+  double tdescriptor_;      // Feature descriptor
+  double tsubpixel_;        // Subpixel refinement
+
+  // Some auxiliary variables used in the AOS step
+  cv::Mat Ltx_, Lty_, px_, py_, ax_, ay_, bx_, by_, qr_, qc_;
+
+public:
+
+  // Constructor
+  KAZE(KAZEOptions& options);
+
+  // Destructor
+  ~KAZE(void);
+
+  // 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);
+
+  // Methods for saving the scale space set of images and detector responses
+  void Save_Nonlinear_Scale_Space(void);
+  void Save_Detector_Responses(void);
+  void Save_Flow_Responses(void);
+
+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);
+  void Feature_Suppression_Distance(std::vector<cv::KeyPoint>& kpts, const float& mdist);
+
+  // 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);
+
+  // Feature Description methods
+  void Compute_Main_Orientation_SURF(cv::KeyPoint& kpt);
+
+  // Descriptor Mode -> 0 SURF 64
+  void Get_SURF_Upright_Descriptor_64(const cv::KeyPoint& kpt, float* desc);
+  void Get_SURF_Descriptor_64(const cv::KeyPoint& kpt, float* desc);
+
+  // Descriptor Mode -> 0 SURF 128
+  void Get_SURF_Upright_Descriptor_128(const cv::KeyPoint& kpt, float* desc);
+  void Get_SURF_Descriptor_128(const cv::KeyPoint& kpt, float* desc);
+
+  // Descriptor Mode -> 1 M-SURF 64
+  void Get_MSURF_Upright_Descriptor_64(const cv::KeyPoint& kpt, float* desc);
+  void Get_MSURF_Descriptor_64(const cv::KeyPoint& kpt, float* desc);
+
+  // Descriptor Mode -> 1 M-SURF 128
+  void Get_MSURF_Upright_Descriptor_128(const cv::KeyPoint& kpt, float* desc);
+  void Get_MSURF_Descriptor_128(const cv::KeyPoint& kpt, float *desc);
+
+  // Descriptor Mode -> 2 G-SURF 64
+  void Get_GSURF_Upright_Descriptor_64(const cv::KeyPoint& kpt, float* desc);
+  void Get_GSURF_Descriptor_64(const cv::KeyPoint& kpt, float *desc);
+
+  // Descriptor Mode -> 2 G-SURF 128
+  void Get_GSURF_Upright_Descriptor_128(const cv::KeyPoint& kpt, float* desc);
+  void Get_GSURF_Descriptor_128(const cv::KeyPoint& kpt, float* desc);
+
+public:
+
+  // Setters
+  void Set_Scale_Offset(float soffset) {
+    soffset_ = soffset;
+  }
+
+  void Set_SDerivatives(float sderivatives) {
+    sderivatives_ = sderivatives;
+  }
+
+  void Set_Octave_Max(int omax) {
+    omax_ = omax;
+  }
+
+  void Set_NSublevels(int nsublevels) {
+    nsublevels_ = nsublevels;
+  }
+
+  void Set_Save_Scale_Space_Flag(bool save_scale_space) {
+    save_scale_space_ = save_scale_space;
+  }
+
+  void Set_Image_Width(int img_width) {
+    img_width_ = img_width;
+  }
+
+  void Set_Image_Height(int img_height) {
+    img_height_ = img_height;
+  }
+
+  void Set_Verbosity_Level(bool verbosity) {
+    verbosity_ = verbosity;
+  }
+
+  void Set_KContrast(float kcontrast) {
+    kcontrast_ = kcontrast;
+  }
+
+  void Set_Detector_Threshold(float dthreshold) {
+    dthreshold_ = dthreshold;
+  }
+
+  void Set_Diffusivity_Type(int diffusivity) {
+    diffusivity_ = diffusivity;
+  }
+
+  void Set_Descriptor_Mode(int descriptor_mode) {
+    descriptor_mode_ = descriptor_mode;
+  }
+
+  void Set_Use_FED(bool use_fed) {
+    use_fed_ = use_fed;
+  }
+
+  void Set_Upright(bool use_upright) {
+    use_upright_ = use_upright;
+  }
+
+  void Set_Extended(bool use_extended) {
+    use_extended_ = use_extended;
+  }
+
+  // Getters
+  float Get_Scale_Offset(void) {
+    return soffset_;
+  }
+
+  float Get_SDerivatives(void) {
+    return sderivatives_;
+  }
+
+  int Get_Octave_Max(void) {
+    return omax_;
+  }
+
+  int Get_NSublevels(void) {
+    return nsublevels_;
+  }
+
+  bool Get_Save_Scale_Space_Flag(void) {
+    return save_scale_space_;
+  }
+
+  int Get_Image_Width(void) {
+    return img_width_;
+  }
+
+  int Get_Image_Height(void) {
+    return img_height_;
+  }
+
+  bool Get_Verbosity_Level(void) {
+    return verbosity_;
+  }
+
+  float Get_KContrast(void) {
+    return kcontrast_;
+  }
+
+  float Get_Detector_Threshold(void) {
+    return dthreshold_;
+  }
+
+  int Get_Diffusivity_Type(void) {
+    return diffusivity_;
+  }
+
+  int Get_Descriptor_Mode(void) {
+    return descriptor_mode_;
+  }
+
+  bool Get_Upright(void) {
+    return use_upright_;
+  }
+
+  bool Get_Extended(void) {
+    return use_extended_;
+  }
+
+  float Get_Time_KContrast(void) {
+    return tkcontrast_;
+  }
+
+  float Get_Time_NLScale(void) {
+    return tnlscale_;
+  }
+
+  float Get_Time_Detector(void) {
+    return tdetector_;
+  }
+
+  float Get_Time_Multiscale_Derivatives(void) {
+    return tmderivatives_;
+  }
+
+  float Get_Time_Detector_Response(void) {
+    return tdresponse_;
+  }
+
+  float Get_Time_Descriptor(void) {
+    return tdescriptor_;
+  }
+
+  float Get_Time_Subpixel(void) {
+    return tsubpixel_;
+  }
+};
+
+//*************************************************************************************
+//*************************************************************************************
+
+// 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/config.h

@@ -0,0 +1,129 @@
+
+/**
+ * @file config.h
+ * @brief Configuration file
+ * @date Dec 27, 2011
+ * @author Pablo F. Alcantarilla
+ */
+
+#ifndef _CONFIG_H_
+#define _CONFIG_H_
+
+//******************************************************************************
+//******************************************************************************
+
+// System Includes
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <cstdlib>
+#include <string>
+#include <vector>
+#include <math.h>
+
+// OpenCV Includes
+#include "precomp.hpp"
+
+// OpenMP Includes
+#ifdef _OPENMP
+#include <omp.h>
+#else
+#define omp_get_thread_num() 0
+#endif
+
+//*************************************************************************************
+//*************************************************************************************
+
+// Some defines
+#define NMAX_CHAR 400
+
+// Some default options
+const float DEFAULT_SCALE_OFFSET = 1.60; // Base scale offset (sigma units)
+const float DEFAULT_OCTAVE_MAX = 4.0; // Maximum octave evolution of the image 2^sigma (coarsest scale sigma units)
+const int DEFAULT_NSUBLEVELS = 4; // Default number of sublevels per scale level
+const float DEFAULT_DETECTOR_THRESHOLD = 0.001; // Detector response threshold to accept point
+const float DEFAULT_MIN_DETECTOR_THRESHOLD = 0.00001;     // Minimum Detector response threshold to accept point
+const int DEFAULT_DESCRIPTOR_MODE = 1; // Descriptor Mode 0->SURF, 1->M-SURF
+const bool DEFAULT_USE_FED = true;  // 0->AOS, 1->FED
+const bool DEFAULT_UPRIGHT = false;  // Upright descriptors, not invariant to rotation
+const bool DEFAULT_EXTENDED = false; // Extended descriptor, dimension 128
+const bool DEFAULT_SAVE_SCALE_SPACE = false; // For saving the scale space images
+const bool DEFAULT_VERBOSITY = false; // Verbosity level (0->no verbosity)
+const bool DEFAULT_SHOW_RESULTS = true; // For showing the output image with the detected features plus some ratios
+const bool DEFAULT_SAVE_KEYPOINTS = false; // For saving the list of keypoints
+
+// Some important configuration variables
+const float DEFAULT_SIGMA_SMOOTHING_DERIVATIVES = 1.0;
+const float DEFAULT_KCONTRAST = .01;
+const float KCONTRAST_PERCENTILE = 0.7;
+const int KCONTRAST_NBINS = 300;
+const bool COMPUTE_KCONTRAST = true;
+const int DEFAULT_DIFFUSIVITY_TYPE = 1;  // 0 -> PM G1, 1 -> PM G2, 2 -> Weickert
+const bool USE_CLIPPING_NORMALIZATION = false;
+const float CLIPPING_NORMALIZATION_RATIO = 1.6;
+const int CLIPPING_NORMALIZATION_NITER = 5;
+
+//*************************************************************************************
+//*************************************************************************************
+
+struct KAZEOptions {
+
+  KAZEOptions() {
+    // Load the default options
+    soffset = DEFAULT_SCALE_OFFSET;
+    omax = DEFAULT_OCTAVE_MAX;
+    nsublevels = DEFAULT_NSUBLEVELS;
+    dthreshold = DEFAULT_DETECTOR_THRESHOLD;
+    use_fed = DEFAULT_USE_FED;
+    upright = DEFAULT_UPRIGHT;
+    extended = DEFAULT_EXTENDED;
+    descriptor = DEFAULT_DESCRIPTOR_MODE;
+    diffusivity = DEFAULT_DIFFUSIVITY_TYPE;
+    sderivatives = DEFAULT_SIGMA_SMOOTHING_DERIVATIVES;
+    save_scale_space = DEFAULT_SAVE_SCALE_SPACE;
+    save_keypoints = DEFAULT_SAVE_KEYPOINTS;
+    verbosity = DEFAULT_VERBOSITY;
+    show_results = DEFAULT_SHOW_RESULTS;
+  }
+
+  float soffset;
+  int omax;
+  int nsublevels;
+  int img_width;
+  int img_height;
+  int diffusivity;
+  float sderivatives;
+  float dthreshold;
+  bool use_fed;
+  bool upright;
+  bool extended;
+  int descriptor;
+  bool save_scale_space;
+  bool save_keypoints;
+  bool verbosity;
+  bool show_results;
+};
+
+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
+};
+
+//*************************************************************************************
+//*************************************************************************************
+
+#endif
+
+
+
+

modules/features2d/src/kaze/fed.cpp

@@ -0,0 +1,192 @@
+//=============================================================================
+//
+// 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 "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.0*t/tau_max+0.25f)-0.5f-1.0e-8f)+ 0.5f);
+  scale = 3.0*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(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 = sqrt(number+1.0);
+    int divisor = 11;
+
+    while (divisor <= upperLimit ) {
+      if (number % divisor == 0)
+      {
+        is_prime = false;
+      }
+
+      divisor +=2;
+    }
+
+    return is_prime;
+  }
+}

modules/features2d/src/kaze/fed.h

@@ -0,0 +1,30 @@
+#ifndef FED_H
+#define FED_H
+
+//******************************************************************************
+//******************************************************************************
+
+// Includes
+#include <iostream>
+#include <stdlib.h>
+#include <stdio.h>
+#include <cstdlib>
+#include <math.h>
+#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.cpp

@@ -0,0 +1,386 @@
+
+//=============================================================================
+//
+// nldiffusion_functions.cpp
+// Author: Pablo F. Alcantarilla
+// Institution: University d'Auvergne
+// Address: Clermont Ferrand, France
+// Date: 27/12/2011
+// Email: pablofdezalc@gmail.com
+//
+// KAZE Features Copyright 2012, Pablo F. Alcantarilla
+// All Rights Reserved
+// See LICENSE for the license information
+//=============================================================================
+
+/**
+ * @file nldiffusion_functions.cpp
+ * @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
+ */
+
+#include "nldiffusion_functions.h"
+
+// Namespaces
+using namespace std;
+using namespace cv;
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function smoothes an image with a Gaussian kernel
+ * @param src Input image
+ * @param dst Output image
+ * @param ksize_x Kernel size in X-direction (horizontal)
+ * @param ksize_y Kernel size in Y-direction (vertical)
+ * @param sigma Kernel standard deviation
+ */
+void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst,
+                             int ksize_x, int ksize_y, float sigma) {
+
+  size_t ksize_x_ = 0, ksize_y_ = 0;
+
+  // Compute an appropriate kernel size according to the specified sigma
+  if (sigma > ksize_x || sigma > ksize_y || ksize_x == 0 || ksize_y == 0) {
+    ksize_x_ = ceil(2.0*(1.0 + (sigma-0.8)/(0.3)));
+    ksize_y_ = ksize_x_;
+  }
+
+  // The kernel size must be and odd number
+  if ((ksize_x_ % 2) == 0) {
+    ksize_x_ += 1;
+  }
+
+  if ((ksize_y_ % 2) == 0) {
+    ksize_y_ += 1;
+  }
+
+  // Perform the Gaussian Smoothing with border replication
+  GaussianBlur(src,dst,Size(ksize_x_,ksize_y_),sigma,sigma,cv::BORDER_REPLICATE);
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function computes the Perona and Malik conductivity coefficient g1
+ * g1 = exp(-|dL|^2/k^2)
+ * @param Lx First order image derivative in X-direction (horizontal)
+ * @param Ly First order image derivative in Y-direction (vertical)
+ * @param dst Output image
+ * @param k Contrast factor parameter
+ */
+void pm_g1(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, float k) {
+  cv::exp(-(Lx.mul(Lx) + Ly.mul(Ly))/(k*k),dst);
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function computes the Perona and Malik conductivity coefficient g2
+ * g2 = 1 / (1 + dL^2 / k^2)
+ * @param Lx First order image derivative in X-direction (horizontal)
+ * @param Ly First order image derivative in Y-direction (vertical)
+ * @param dst Output image
+ * @param k Contrast factor parameter
+ */
+void pm_g2(const cv::Mat &Lx, const cv::Mat& Ly, cv::Mat& dst, float k) {
+  dst = 1./(1. + (Lx.mul(Lx) + Ly.mul(Ly))/(k*k));
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function computes Weickert conductivity coefficient g3
+ * @param Lx First order image derivative in X-direction (horizontal)
+ * @param Ly First order image derivative in Y-direction (vertical)
+ * @param dst Output image
+ * @param k Contrast factor parameter
+ * @note For more information check the following paper: J. Weickert
+ * Applications of nonlinear diffusion in image processing and computer vision,
+ * Proceedings of Algorithmy 2000
+ */
+void weickert_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, float k) {
+  Mat modg;
+  cv::pow((Lx.mul(Lx) + Ly.mul(Ly))/(k*k),4,modg);
+  cv::exp(-3.315/modg, dst);
+  dst = 1.0 - dst;
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function computes a good empirical value for the k contrast factor
+ * given an input image, the percentile (0-1), the gradient scale and the number of
+ * bins in the histogram
+ * @param img Input image
+ * @param perc Percentile of the image gradient histogram (0-1)
+ * @param gscale Scale for computing the image gradient histogram
+ * @param nbins Number of histogram bins
+ * @param ksize_x Kernel size in X-direction (horizontal) for the Gaussian smoothing kernel
+ * @param ksize_y Kernel size in Y-direction (vertical) for the Gaussian smoothing kernel
+ * @return k contrast factor
+ */
+float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
+                           int nbins, int ksize_x, int ksize_y) {
+
+  int nbin = 0, nelements = 0, nthreshold = 0, k = 0;
+  float kperc = 0.0, modg = 0.0, lx = 0.0, ly = 0.0;
+  float npoints = 0.0;
+  float hmax = 0.0;
+
+  // Create the array for the histogram
+  float *hist = new float[nbins];
+
+  // Create the matrices
+  Mat gaussian = Mat::zeros(img.rows,img.cols,CV_32F);
+  Mat Lx = Mat::zeros(img.rows,img.cols,CV_32F);
+  Mat Ly = Mat::zeros(img.rows,img.cols,CV_32F);
+
+  // Set the histogram to zero, just in case
+  for (int i = 0; i < nbins; i++) {
+    hist[i] = 0.0;
+  }
+
+  // Perform the Gaussian convolution
+  gaussian_2D_convolution(img,gaussian,ksize_x,ksize_y,gscale);
+
+  // Compute the Gaussian derivatives Lx and Ly
+  Scharr(gaussian,Lx,CV_32F,1,0,1,0,cv::BORDER_DEFAULT);
+  Scharr(gaussian,Ly,CV_32F,0,1,1,0,cv::BORDER_DEFAULT);
+
+  // Skip the borders for computing the histogram
+  for (int i = 1; i < gaussian.rows-1; i++) {
+    for (int j = 1; j < gaussian.cols-1; j++) {
+      lx = *(Lx.ptr<float>(i)+j);
+      ly = *(Ly.ptr<float>(i)+j);
+      modg = sqrt(lx*lx + ly*ly);
+
+      // Get the maximum
+      if (modg > hmax) {
+        hmax = modg;
+      }
+    }
+  }
+
+  // Skip the borders for computing the histogram
+  for (int i = 1; i < gaussian.rows-1; i++) {
+    for (int j = 1; j < gaussian.cols-1; j++) {
+      lx = *(Lx.ptr<float>(i)+j);
+      ly = *(Ly.ptr<float>(i)+j);
+      modg = sqrt(lx*lx + ly*ly);
+
+      // Find the correspondent bin
+      if (modg != 0.0) {
+        nbin = floor(nbins*(modg/hmax));
+
+        if (nbin == nbins) {
+          nbin--;
+        }
+
+        hist[nbin]++;
+        npoints++;
+      }
+    }
+  }
+
+  // Now find the perc of the histogram percentile
+  nthreshold = (size_t)(npoints*perc);
+
+
+  for (k = 0; nelements < nthreshold && k < nbins; k++) {
+    nelements = nelements + hist[k];
+  }
+
+  if (nelements < nthreshold)  {
+    kperc = 0.03;
+  }
+  else {
+    kperc = hmax*((float)(k)/(float)nbins);
+  }
+
+  delete hist;
+  return kperc;
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function computes Scharr image derivatives
+ * @param src Input image
+ * @param dst Output image
+ * @param xorder Derivative order in X-direction (horizontal)
+ * @param yorder Derivative order in Y-direction (vertical)
+ * @param scale Scale factor or derivative size
+ */
+void compute_scharr_derivatives(const cv::Mat& src, cv::Mat& dst,
+                                int xorder, int yorder, int scale) {
+  Mat kx, ky;
+  compute_derivative_kernels(kx,ky,xorder,yorder,scale);
+  sepFilter2D(src,dst,CV_32F,kx,ky);
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief Compute derivative kernels for sizes different than 3
+ * @param _kx Horizontal kernel values
+ * @param _ky Vertical kernel values
+ * @param dx Derivative order in X-direction (horizontal)
+ * @param dy Derivative order in Y-direction (vertical)
+ * @param scale_ Scale factor or derivative size
+ */
+void compute_derivative_kernels(cv::OutputArray _kx, cv::OutputArray _ky,
+                                int dx, int dy, int scale) {
+
+  int ksize = 3 + 2*(scale-1);
+
+  // The standard Scharr kernel
+  if (scale == 1) {
+    getDerivKernels(_kx,_ky,dx,dy,0,true,CV_32F);
+    return;
+  }
+
+  _kx.create(ksize,1,CV_32F,-1,true);
+  _ky.create(ksize,1,CV_32F,-1,true);
+  Mat kx = _kx.getMat();
+  Mat ky = _ky.getMat();
+
+  float w = 10.0/3.0;
+  float norm = 1.0/(2.0*scale*(w+2.0));
+
+  for (int k = 0; k < 2; k++) {
+    Mat* kernel = k == 0 ? &kx : &ky;
+    int order = k == 0 ? dx : dy;
+	std::vector<float> kerI(ksize);
+
+    for (int t=0; t<ksize; t++) {
+      kerI[t] = 0;
+    }
+
+    if (order == 0) {
+      kerI[0] = norm, kerI[ksize/2] = w*norm, kerI[ksize-1] = norm;
+    }
+    else if (order == 1) {
+      kerI[0] = -1, kerI[ksize/2] = 0, kerI[ksize-1] = 1;
+    }
+
+    Mat temp(kernel->rows,kernel->cols,CV_32F,&kerI[0]);
+    temp.copyTo(*kernel);
+  }
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function performs a scalar non-linear diffusion step
+ * @param Ld2 Output image in the evolution
+ * @param c Conductivity image
+ * @param Lstep Previous image in the evolution
+ * @param stepsize The step size in time units
+ * @note Forward Euler Scheme 3x3 stencil
+ * The function c is a scalar value that depends on the gradient norm
+ * dL_by_ds = d(c dL_by_dx)_by_dx + d(c dL_by_dy)_by_dy
+ */
+void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsize) {
+
+#ifdef _OPENMP
+#pragma omp parallel for schedule(dynamic)
+#endif
+  for (int i = 1; i < Lstep.rows-1; i++) {
+    for (int j = 1; j < Lstep.cols-1; j++) {
+      float xpos = ((*(c.ptr<float>(i)+j))+(*(c.ptr<float>(i)+j+1)))*((*(Ld.ptr<float>(i)+j+1))-(*(Ld.ptr<float>(i)+j)));
+      float xneg = ((*(c.ptr<float>(i)+j-1))+(*(c.ptr<float>(i)+j)))*((*(Ld.ptr<float>(i)+j))-(*(Ld.ptr<float>(i)+j-1)));
+      float ypos = ((*(c.ptr<float>(i)+j))+(*(c.ptr<float>(i+1)+j)))*((*(Ld.ptr<float>(i+1)+j))-(*(Ld.ptr<float>(i)+j)));
+      float yneg = ((*(c.ptr<float>(i-1)+j))+(*(c.ptr<float>(i)+j)))*((*(Ld.ptr<float>(i)+j))-(*(Ld.ptr<float>(i-1)+j)));
+      *(Lstep.ptr<float>(i)+j) = 0.5*stepsize*(xpos-xneg + ypos-yneg);
+    }
+  }
+
+  for (int j = 1; j < Lstep.cols-1; j++) {
+    float xpos = ((*(c.ptr<float>(0)+j))+(*(c.ptr<float>(0)+j+1)))*((*(Ld.ptr<float>(0)+j+1))-(*(Ld.ptr<float>(0)+j)));
+    float xneg = ((*(c.ptr<float>(0)+j-1))+(*(c.ptr<float>(0)+j)))*((*(Ld.ptr<float>(0)+j))-(*(Ld.ptr<float>(0)+j-1)));
+    float ypos = ((*(c.ptr<float>(0)+j))+(*(c.ptr<float>(1)+j)))*((*(Ld.ptr<float>(1)+j))-(*(Ld.ptr<float>(0)+j)));
+    float yneg = ((*(c.ptr<float>(0)+j))+(*(c.ptr<float>(0)+j)))*((*(Ld.ptr<float>(0)+j))-(*(Ld.ptr<float>(0)+j)));
+    *(Lstep.ptr<float>(0)+j) = 0.5*stepsize*(xpos-xneg + ypos-yneg);
+  }
+
+  for (int j = 1; j < Lstep.cols-1; j++) {
+    float xpos = ((*(c.ptr<float>(Lstep.rows-1)+j))+(*(c.ptr<float>(Lstep.rows-1)+j+1)))*((*(Ld.ptr<float>(Lstep.rows-1)+j+1))-(*(Ld.ptr<float>(Lstep.rows-1)+j)));
+    float xneg = ((*(c.ptr<float>(Lstep.rows-1)+j-1))+(*(c.ptr<float>(Lstep.rows-1)+j)))*((*(Ld.ptr<float>(Lstep.rows-1)+j))-(*(Ld.ptr<float>(Lstep.rows-1)+j-1)));
+    float ypos = ((*(c.ptr<float>(Lstep.rows-1)+j))+(*(c.ptr<float>(Lstep.rows-1)+j)))*((*(Ld.ptr<float>(Lstep.rows-1)+j))-(*(Ld.ptr<float>(Lstep.rows-1)+j)));
+    float yneg = ((*(c.ptr<float>(Lstep.rows-2)+j))+(*(c.ptr<float>(Lstep.rows-1)+j)))*((*(Ld.ptr<float>(Lstep.rows-1)+j))-(*(Ld.ptr<float>(Lstep.rows-2)+j)));
+    *(Lstep.ptr<float>(Lstep.rows-1)+j) = 0.5*stepsize*(xpos-xneg + ypos-yneg);
+  }
+
+  for (int i = 1; i < Lstep.rows-1; i++) {
+    float xpos = ((*(c.ptr<float>(i)))+(*(c.ptr<float>(i)+1)))*((*(Ld.ptr<float>(i)+1))-(*(Ld.ptr<float>(i))));
+    float xneg = ((*(c.ptr<float>(i)))+(*(c.ptr<float>(i))))*((*(Ld.ptr<float>(i)))-(*(Ld.ptr<float>(i))));
+    float ypos = ((*(c.ptr<float>(i)))+(*(c.ptr<float>(i+1))))*((*(Ld.ptr<float>(i+1)))-(*(Ld.ptr<float>(i))));
+    float yneg = ((*(c.ptr<float>(i-1)))+(*(c.ptr<float>(i))))*((*(Ld.ptr<float>(i)))-(*(Ld.ptr<float>(i-1))));
+    *(Lstep.ptr<float>(i)) = 0.5*stepsize*(xpos-xneg + ypos-yneg);
+  }
+
+  for (int i = 1; i < Lstep.rows-1; i++) {
+    float xpos = ((*(c.ptr<float>(i)+Lstep.cols-1))+(*(c.ptr<float>(i)+Lstep.cols-1)))*((*(Ld.ptr<float>(i)+Lstep.cols-1))-(*(Ld.ptr<float>(i)+Lstep.cols-1)));
+    float xneg = ((*(c.ptr<float>(i)+Lstep.cols-2))+(*(c.ptr<float>(i)+Lstep.cols-1)))*((*(Ld.ptr<float>(i)+Lstep.cols-1))-(*(Ld.ptr<float>(i)+Lstep.cols-2)));
+    float ypos = ((*(c.ptr<float>(i)+Lstep.cols-1))+(*(c.ptr<float>(i+1)+Lstep.cols-1)))*((*(Ld.ptr<float>(i+1)+Lstep.cols-1))-(*(Ld.ptr<float>(i)+Lstep.cols-1)));
+    float yneg = ((*(c.ptr<float>(i-1)+Lstep.cols-1))+(*(c.ptr<float>(i)+Lstep.cols-1)))*((*(Ld.ptr<float>(i)+Lstep.cols-1))-(*(Ld.ptr<float>(i-1)+Lstep.cols-1)));
+    *(Lstep.ptr<float>(i)+Lstep.cols-1) = 0.5*stepsize*(xpos-xneg + ypos-yneg);
+  }
+
+  Ld = Ld + Lstep;
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function checks if a given pixel is a maximum in a local neighbourhood
+ * @param img Input image where we will perform the maximum search
+ * @param dsize Half size of the neighbourhood
+ * @param value Response value at (x,y) position
+ * @param row Image row coordinate
+ * @param col Image column coordinate
+ * @param same_img Flag to indicate if the image value at (x,y) is in the input image
+ * @return 1->is maximum, 0->otherwise
+ */
+bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value,
+                                 int row, int col, bool same_img) {
+
+  bool response = true;
+
+  for (int i = row-dsize; i <= row+dsize; i++) {
+    for (int j = col-dsize; j <= col+dsize; j++) {
+      if (i >= 0 && i < img.rows && j >= 0 && j < img.cols) {
+        if (same_img == true) {
+          if (i != row || j != col) {
+            if ((*(img.ptr<float>(i)+j)) > value) {
+              response = false;
+              return response;
+            }
+          }
+        }
+        else {
+          if ((*(img.ptr<float>(i)+j)) > value) {
+            response = false;
+            return response;
+          }
+        }
+      }
+    }
+  }
+
+  return response;
+}

modules/features2d/src/kaze/nldiffusion_functions.h

@@ -0,0 +1,51 @@
+
+/**
+ * @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 NLDIFFUSION_FUNCTIONS_H_
+#define NLDIFFUSION_FUNCTIONS_H_
+
+//******************************************************************************
+//******************************************************************************
+
+// Includes
+#include "config.h"
+
+//*************************************************************************************
+//*************************************************************************************
+
+// 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);
+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);
+
+// 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);
+
+//*************************************************************************************
+//*************************************************************************************
+
+#endif // NLDIFFUSION_FUNCTIONS_H_

modules/features2d/src/kaze/utils.cpp

@@ -0,0 +1,92 @@
+
+//=============================================================================
+//
+// utils.cpp
+// Author: Pablo F. Alcantarilla
+// Institution: University d'Auvergne
+// Address: Clermont Ferrand, France
+// Date: 29/12/2011
+// Email: pablofdezalc@gmail.com
+//
+// KAZE Features Copyright 2012, Pablo F. Alcantarilla
+// All Rights Reserved
+// See LICENSE for the license information
+//=============================================================================
+
+/**
+ * @file utils.cpp
+ * @brief Some useful functions
+ * @date Dec 29, 2011
+ * @author Pablo F. Alcantarilla
+ */
+
+#include "utils.h"
+
+using namespace std;
+using namespace cv;
+
+//*************************************************************************************
+//*************************************************************************************
+
+/**
+ * @brief This function copies the input image and converts the scale of the copied
+ * image prior visualization
+ * @param src Input image
+ * @param dst Output image
+ */
+void copy_and_convert_scale(const cv::Mat& src, cv::Mat& dst) {
+
+  float min_val = 0, max_val = 0;
+
+  src.copyTo(dst);
+  compute_min_32F(dst,min_val);
+
+  dst = dst - min_val;
+
+  compute_max_32F(dst,max_val);
+  dst = dst / max_val;
+}
+
+//*************************************************************************************
+//*************************************************************************************
+
+/*
+void show_input_options_help(int example) {
+
+  fflush(stdout);
+
+  cout << endl;
+  cout << endl;
+  cout << "KAZE Features" << endl;
+  cout << "***********************************************************" << endl;
+  cout << "For running the program you need to type in the command line the following arguments: " << endl;
+
+  if (example == 0) {
+    cout << "./kaze_features img.jpg [options]" << endl;
+  }
+  else if (example == 1) {
+    cout << "./kaze_match img1.jpg img2.pgm homography.txt [options]" << endl;
+  }
+  else if (example == 2) {
+    cout << "./kaze_compare img1.jpg img2.pgm homography.txt [options]" << endl;
+  }
+
+  cout << endl;
+  cout << "The options are not mandatory. In case you do not specify additional options, default arguments will be used" << endl << endl;
+  cout << "Here is a description of the additional options: " << endl;
+  cout << "--verbose " << "\t\t if verbosity is required" << endl;
+  cout << "--help" << "\t\t for showing the command line options" << endl;
+  cout << "--soffset" << "\t\t the base scale offset (sigma units)" << endl;
+  cout << "--omax" << "\t\t maximum octave evolution of the image 2^sigma (coarsest scale)" << endl;
+  cout << "--nsublevels" << "\t\t number of sublevels per octave" << endl;
+  cout << "--dthreshold" << "\t\t Feature detector threshold response for accepting points (0.001 can be a good value)" << endl;
+  cout << "--descriptor" << "\t\t Descriptor Type 0 -> SURF, 1 -> M-SURF, 2 -> G-SURF" << endl;
+  cout << "--use_fed" "\t\t 1 -> Use FED, 0 -> Use AOS for the nonlinear diffusion filtering" << endl;
+  cout << "--upright" << "\t\t 0 -> Rotation Invariant, 1 -> No Rotation Invariant" << endl;
+  cout << "--extended" << "\t\t 0 -> Normal Descriptor (64), 1 -> Extended Descriptor (128)" << endl;
+  cout << "--output keypoints.txt" << "\t\t For saving the detected keypoints into a .txt file" << endl;
+  cout << "--save_scale_space" << "\t\t 1 in case we want to save the nonlinear scale space images. 0 otherwise" << endl;
+  cout << "--show_results" << "\t\t 1 in case we want to show detection results. 0 otherwise" << endl;
+  cout << endl;
+}
+*/

modules/features2d/src/kaze/utils.h

@@ -0,0 +1,41 @@
+
+/**
+ * @file utils.h
+ * @brief Some useful functions
+ * @date Dec 29, 2011
+ * @author Pablo F. Alcantarilla
+ */
+
+#ifndef UTILS_H_
+#define UTILS_H_
+
+//******************************************************************************
+//******************************************************************************
+
+// OPENCV Includes
+#include "precomp.hpp"
+
+// System Includes
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <cstdlib>
+#include <string>
+#include <vector>
+#include <fstream>
+#include <assert.h>
+#include <math.h>
+
+//*************************************************************************************
+//*************************************************************************************
+
+// Declaration of Functions
+void compute_min_32F(const cv::Mat& src, float& value);
+void compute_max_32F(const cv::Mat& src, float& value);
+void convert_scale(cv::Mat& src);
+void copy_and_convert_scale(const cv::Mat &src, cv::Mat& dst);
+
+//*************************************************************************************
+//*************************************************************************************
+
+#endif // UTILS_H_