Wrapped nldiffusion functions with details::kaze or details::amaze namespace to…

Wrapped nldiffusion functions with details::kaze or details::amaze namespace to avoid collision of function names

modules/features2d/src/akaze/AKAZEConfig.h

@@ -114,7 +114,7 @@ struct AKAZEOptions {
 
     float kcontrast;                ///< The contrast factor parameter
     float kcontrast_percentile;     ///< Percentile level for the contrast factor
-    size_t kcontrast_nbins;         ///< Number of bins for the contrast factor histogram
+    int kcontrast_nbins;            ///< Number of bins for the contrast factor histogram
 
     bool save_scale_space;          ///< Set to true for saving the scale space images
     bool save_keypoints;            ///< Set to true for saving the detected keypoints and descriptors

modules/features2d/src/akaze/AKAZEFeatures.cpp

@@ -12,6 +12,7 @@
 
 using namespace std;
 using namespace cv;
+using namespace cv::details::akaze;
 
 /* ************************************************************************* */
 /**
@@ -110,8 +111,7 @@ int AKAZEFeatures::Create_Nonlinear_Scale_Space(const cv::Mat& img) {
     evolution_[0].Lt.copyTo(evolution_[0].Lsmooth);
 
     // First compute the kcontrast factor
-    options_.kcontrast = compute_k_percentile(img, options_.kcontrast_percentile,
-        1.0f, options_.kcontrast_nbins, 0, 0);
+    options_.kcontrast = compute_k_percentile(img, options_.kcontrast_percentile, 1.0f, options_.kcontrast_nbins, 0, 0);
 
     //t2 = cv::getTickCount();
     //timing_.kcontrast = 1000.0*(t2 - t1) / cv::getTickFrequency();

modules/features2d/src/akaze/nldiffusion_functions.h

@@ -5,7 +5,8 @@
  * @author Pablo F. Alcantarilla, Jesus Nuevo
  */
 
-#pragma once
+#ifndef AKAZE_NLDIFFUSION_FUNCTIONS_H
+#define AKAZE_NLDIFFUSION_FUNCTIONS_H
 
 /* ************************************************************************* */
 // Includes
@@ -13,20 +14,27 @@
 
 /* ************************************************************************* */
 // Declaration of functions
-void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, const size_t& ksize_x,
-                             const size_t& ksize_y, const float& sigma);
-void image_derivatives_scharr(const cv::Mat& src, cv::Mat& dst,
-                              const size_t& xorder, const size_t& yorder);
-void pm_g1(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
-void pm_g2(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
-void weickert_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
-void charbonnier_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
-float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
-                           size_t nbins, size_t ksize_x, size_t ksize_y);
-void compute_scharr_derivatives(const cv::Mat& src, cv::Mat& dst, int xorder, int, int scale);
-void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, const float& stepsize);
-void downsample_image(const cv::Mat& src, cv::Mat& dst);
-void halfsample_image(const cv::Mat& src, cv::Mat& dst);
-void compute_derivative_kernels(cv::OutputArray kx_, cv::OutputArray ky_, int dx, int dy, int scale);
-bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value,
-                                 int row, int col, bool same_img);
+
+namespace cv {
+    namespace details {
+        namespace akaze {
+
+            void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, int ksize_x, int ksize_y, float sigma);
+            void image_derivatives_scharr(const cv::Mat& src, cv::Mat& dst, int xorder, int yorder);
+            void pm_g1(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
+            void pm_g2(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
+            void weickert_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
+            void charbonnier_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, const float& k);
+            float compute_k_percentile(const cv::Mat& img, float perc, float gscale, int nbins, int ksize_x, int ksize_y);
+            void compute_scharr_derivatives(const cv::Mat& src, cv::Mat& dst, int xorder, int, int scale);
+            void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, const float& stepsize);
+            void downsample_image(const cv::Mat& src, cv::Mat& dst);
+            void halfsample_image(const cv::Mat& src, cv::Mat& dst);
+            void compute_derivative_kernels(cv::OutputArray kx_, cv::OutputArray ky_, int dx, int dy, int scale);
+            bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value, int row, int col, bool same_img);
+
+        }
+    }
+}
+
+#endif

modules/features2d/src/kaze/KAZEFeatures.cpp

@@ -26,6 +26,7 @@
 // Namespaces
 using namespace std;
 using namespace cv;
+using namespace cv::details::kaze;
 
 //*******************************************************************************
 //*******************************************************************************

modules/features2d/src/kaze/nldiffusion_functions.h

-
 /**
  * @file nldiffusion_functions.h
  * @brief Functions for non-linear diffusion applications:
@@ -9,43 +8,40 @@
  * @author Pablo F. Alcantarilla
  */
 
-#ifndef NLDIFFUSION_FUNCTIONS_H_
-#define NLDIFFUSION_FUNCTIONS_H_
-
-//******************************************************************************
-//******************************************************************************
+#ifndef KAZE_NLDIFFUSION_FUNCTIONS_H
+#define KAZE_NLDIFFUSION_FUNCTIONS_H
 
 // Includes
-#include "config.h"
+#include "precomp.hpp"
 
 //*************************************************************************************
 //*************************************************************************************
 
-// Gaussian 2D convolution
-void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst,
-                             int ksize_x, int ksize_y, float sigma);
+namespace cv {
+    namespace details {
+        namespace kaze {
 
-// 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);
+            // Gaussian 2D convolution
+            void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, int ksize_x, int ksize_y, float sigma);
 
-// 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);
+            // 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);
 
-// Nonlinear diffusion filtering scalar step
-void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsize);
+            // 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);
 
-// For non-maxima suppresion
-bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value,
-                                 int row, int col, bool same_img);
+            // 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_
+#endif