generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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

Browse Source
This commit is contained in:
Ievgen Khvedchenia 2014-04-28 20:41:44 +03:00
parent c68cbfced3
commit c1bf453266
7 changed files with 697 additions and 681 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/features2d/src/akaze/AKAZEConfig.h
View File

@ -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

4
modules/features2d/src/akaze/AKAZEFeatures.cpp
View File

@ -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();

23
modules/features2d/src/akaze/nldiffusion_functions.cpp
View File

@ -19,11 +19,15 @@
* @author Pablo F. Alcantarilla, Jesus Nuevo
*/
#include "nldiffusion_functions.h"
#include "akaze/nldiffusion_functions.h"
using namespace std;
using namespace cv;
namespace cv {
namespace details {
namespace akaze {
/* ************************************************************************* */
/**
* @brief This function smoothes an image with a Gaussian kernel
@ -33,8 +37,7 @@ using namespace cv;
* @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, const size_t& ksize_x,
const size_t& ksize_y, const float& sigma) {
void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst, int ksize_x, int ksize_y, float sigma) {
int ksize_x_ = 0, ksize_y_ = 0;
@ -148,16 +151,15 @@ void charbonnier_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst,
* @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,
size_t nbins, size_t ksize_x, size_t ksize_y) {
float compute_k_percentile(const cv::Mat& img, float perc, float gscale, int nbins, int ksize_x, int ksize_y) {
size_t nbin = 0, nelements = 0, nthreshold = 0, k = 0;
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
std::vector<size_t> hist(nbins, 0);
std::vector<int> hist(nbins, 0);
// Create the matrices
cv::Mat gaussian = cv::Mat::zeros(img.rows, img.cols, CV_32F);
@ -194,7 +196,7 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
// Find the correspondent bin
if (modg != 0.0) {
nbin = (size_t)floor(nbins*(modg / hmax));
nbin = (int)floor(nbins*(modg / hmax));
if (nbin == nbins) {
nbin--;
@ -207,7 +209,7 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
}
// Now find the perc of the histogram percentile
nthreshold = (size_t)(npoints*perc);
nthreshold = (int)(npoints*perc);
for (k = 0; nelements < nthreshold && k < nbins; k++) {
nelements = nelements + hist[k];
@ -384,3 +386,6 @@ void compute_derivative_kernels(cv::OutputArray kx_, cv::OutputArray ky_, int dx
temp.copyTo(*kernel);
}
}
}
}
}

26
modules/features2d/src/akaze/nldiffusion_functions.h
View File

@ -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);
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,
size_t nbins, size_t ksize_x, size_t ksize_y);
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);
bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value, int row, int col, bool same_img);
}
}
}
#endif

1
modules/features2d/src/kaze/KAZEFeatures.cpp
View File

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

10
modules/features2d/src/kaze/nldiffusion_functions.cpp
View File

@ -28,10 +28,14 @@
// Namespaces
using namespace std;
using namespace cv;
using namespace cv::details::kaze;
//*************************************************************************************
//*************************************************************************************
namespace cv {
namespace details {
namespace kaze {
/**
* @brief This function smoothes an image with a Gaussian kernel
* @param src Input image
@ -129,8 +133,7 @@ void weickert_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, fl
* @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) {
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;
@ -374,3 +377,6 @@ bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value,
return response;
}
}
}
}

36
modules/features2d/src/kaze/nldiffusion_functions.h
View File

@ -1,4 +1,3 @@
/**
* @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"
//*************************************************************************************
//*************************************************************************************
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);
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);
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 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);
bool check_maximum_neighbourhood(const cv::Mat& img, int dsize, float value, int row, int col, bool same_img);
//*************************************************************************************
//*************************************************************************************
}
}
}
#endif // NLDIFFUSION_FUNCTIONS_H_
#endif