diff --git a/modules/features2d/src/kaze/nldiffusion_functions.cpp b/modules/features2d/src/kaze/nldiffusion_functions.cpp
index d76a3c40f..ce3bef175 100644
--- a/modules/features2d/src/kaze/nldiffusion_functions.cpp
+++ b/modules/features2d/src/kaze/nldiffusion_functions.cpp
@@ -47,7 +47,7 @@ void gaussian_2D_convolution(const cv::Mat& src, cv::Mat& dst,
 
   // 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_x_ = (size_t)ceil(2.0f*(1.0f + (sigma-0.8f)/(0.3f)));
     ksize_y_ = ksize_x_;
   }
 
@@ -111,7 +111,7 @@ void weickert_diffusivity(const cv::Mat& Lx, const cv::Mat& Ly, cv::Mat& dst, fl
   Mat modg;
   cv::pow((Lx.mul(Lx) + Ly.mul(Ly))/(k*k),4,modg);
   cv::exp(-3.315/modg, dst);
-  dst = 1.0 - dst;
+  dst = 1.0f - dst;
 }
 
 //*************************************************************************************
@@ -138,18 +138,13 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
   float hmax = 0.0;
 
   // Create the array for the histogram
-  float *hist = new float[nbins];
+  std::vector<int> hist(nbins, 0);
 
   // 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);
 
@@ -180,7 +175,7 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
 
       // Find the correspondent bin
       if (modg != 0.0) {
-        nbin = floor(nbins*(modg/hmax));
+        nbin = (int)floor(nbins*(modg/hmax));
 
         if (nbin == nbins) {
           nbin--;
@@ -207,7 +202,6 @@ float compute_k_percentile(const cv::Mat& img, float perc, float gscale,
     kperc = hmax*((float)(k)/(float)nbins);
   }
 
-  delete hist;
   return kperc;
 }
 
@@ -256,8 +250,8 @@ void compute_derivative_kernels(cv::OutputArray _kx, cv::OutputArray _ky,
   Mat kx = _kx.getMat();
   Mat ky = _ky.getMat();
 
-  float w = 10.0/3.0;
-  float norm = 1.0/(2.0*scale*(w+2.0));
+  float w = 10.0f/3.0f;
+  float norm = 1.0f/(2.0f*scale*(w+2.0f));
 
   for (int k = 0; k < 2; k++) {
     Mat* kernel = k == 0 ? &kx : &ky;
@@ -300,7 +294,7 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsi
       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);
+      *(Lstep.ptr<float>(i)+j) = 0.5f*stepsize*(xpos-xneg + ypos-yneg);
     }
   }
 
@@ -309,7 +303,7 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsi
     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);
+    *(Lstep.ptr<float>(0)+j) = 0.5f*stepsize*(xpos-xneg + ypos-yneg);
   }
 
   for (int j = 1; j < Lstep.cols-1; j++) {
@@ -317,7 +311,7 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsi
     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);
+    *(Lstep.ptr<float>(Lstep.rows-1)+j) = 0.5f*stepsize*(xpos-xneg + ypos-yneg);
   }
 
   for (int i = 1; i < Lstep.rows-1; i++) {
@@ -325,7 +319,7 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsi
     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);
+    *(Lstep.ptr<float>(i)) = 0.5f*stepsize*(xpos-xneg + ypos-yneg);
   }
 
   for (int i = 1; i < Lstep.rows-1; i++) {
@@ -333,7 +327,7 @@ void nld_step_scalar(cv::Mat& Ld, const cv::Mat& c, cv::Mat& Lstep, float stepsi
     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);
+    *(Lstep.ptr<float>(i)+Lstep.cols-1) = 0.5f*stepsize*(xpos-xneg + ypos-yneg);
   }
 
   Ld = Ld + Lstep;