mirror of https://github.com/opencv/opencv.git
Merge pull request #8951 from hrnr:akaze_part2
[GSOC] Speeding-up AKAZE, part #2 (#8951)
* feature2d: instrument more functions used in AKAZE
* rework Compute_Determinant_Hessian_Response
* this takes 84% of time of Feature_Detection
* run everything in parallel
* compute Scharr kernels just once
* compute sigma more efficiently
* allocate all matrices in evolution without zeroing
* features2d: add one bigger image to tests
* now test have images: 600x768, 900x600 and 1385x700 to cover different resolutions
* explicitly zero Lx and Ly
* add Lflow and Lstep to evolution as in original AKAZE code
* reworked computing keypoints orientation
integrated faster function from https://github.com/h2suzuki/fast_akaze
* use standard fastAtan2 instead of getAngle
* compute keypoints orientation in parallel
* fix visual studio warnings
* replace some wrapped functions with direct calls to OpenCV functions
* improved readability for people familiar with opencv
* do not same image twice in base level
* rework diffusity stencil
* use one pass stencil for diffusity from https://github.com/h2suzuki/fast_akaze
* improve locality in Create_Scale_Space
* always compute determinat od hessian and spacial derivatives
* this needs to be computed always as we need derivatives while computing descriptors
* fixed tests of AKAZE with KAZE descriptors which have been affected by this
Currently it computes all first and second order derivatives together and the determiant of the hessian. For descriptors it would be enough to compute just first order derivates, but it is not probably worth it optimize for scenario where descriptors and keypoints are computed separately, since it is already very inefficient. When computing keypoint and descriptors together it is faster to do it the current way (preserves locality).
* parallelize non linear diffusion computation
* do multiplication right in the nlp diffusity kernel
* rework kfactor computation
* get rid of sharing buffers when creating scale space pyramid, the performace impact is neglegible
* features2d: initialize TBB scheduler in perf tests
* ensures more stable output
* more reasonable profiles, since the first call of parallel_for_ is not getting big performace hit
* compute_kfactor: interleave finding of maximum and computing distance
* no need to go twice through the data
* start to use UMats in AKAZE to leverage OpenCl in the future
* fixed bug that prevented computing determinant for scale pyramid of size 1 (just the base image)
* all descriptors now support writing to uninitialized memory
* use InputArray and OutputArray for input image and descriptors, allows to make use UMAt that user passes to us
* enable use of all existing ocl paths in AKAZE
* all parts that uses ocl-enabled functions should use ocl by now
* imgproc: fix dispatching of IPP version when OCL is disabled
* when OCL is disabled IPP version should be always prefered (even when the dst is UMat)
* get rid of copy in DeterminantHessian response
* this slows CPU version considerably
* do no run in parallel when running with OCL
* store derivations as UMat in pyramid
* enables OCL path computing of determint hessian
* will allow to compute descriptors on GPU in the future
* port diffusivity to OCL
* diffusivity itself is not a blocker, but this saves us downloading and uploading derivations
* implement kernel for nonlinear scalar diffusion step
* download the pyramid from GPU just once
we don't want to downlaod matrices ad hoc from gpu when the function in AKAZE needs it. There is a HUGE mapping overhead and without shared memory support a LOT of unnecessary transfers.
This maps/downloads matrices just once.
* fix bug with uninitialized values in non linear diffusion
* this was causing spurious segfaults in stitching tests due to propagation of NaNs
* added new test, which checks for NaNs (added new debug asserts for NaNs)
* valgrind now says everything is ok
* add nonlinear diffusion step OCL implementation
* Lt in pyramid changed to UMat, it will be downlaoded from GPU along with Lx, Ly
* fix bug in pm_g2 kernel. OpenCV mangles dimensions passed to OpenCL, so we need to check for boundaries in each OCL kernel.
* port computing of determinant to OCL
* computing of determinant is not a blocker, but with this change we don't need to download all spatial derivatives to CPU, we only download determinant
* make Ldet in the pyramid UMat, download it from CPU together with the other parts of the pyramid
* add profiling macros
* fix visual studio warning
* instrument non_linear_diffusion
* remove changes I have made to TEvolution
* TEvolution is used only in KAZE now
* Revert "features2d: initialize TBB scheduler in perf tests"
This reverts commit ba81e2a711.
pull/9286/head
Jiri Horner
7 years ago
committed by
Alexander Alekhin
parent
2959e7aba9
commit
bb6496d9e5
13 changed files with 1019 additions and 304 deletions
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,122 @@ |
||||
// This file is part of OpenCV project. |
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory |
||||
// of this distribution and at http://opencv.org/license.html |
||||
|
||||
|
||||
/** |
||||
* @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 |
||||
*/ |
||||
__kernel void |
||||
AKAZE_pm_g2(__global const float* lx, __global const float* ly, __global float* dst, |
||||
float k, int size) |
||||
{ |
||||
int i = get_global_id(0); |
||||
// OpenCV plays with dimensions so we need explicit check for this |
||||
if (!(i < size)) |
||||
{ |
||||
return; |
||||
} |
||||
|
||||
const float k2inv = 1.0f / (k * k); |
||||
dst[i] = 1.0f / (1.0f + ((lx[i] * lx[i] + ly[i] * ly[i]) * k2inv)); |
||||
} |
||||
|
||||
__kernel void |
||||
AKAZE_nld_step_scalar(__global const float* lt, int lt_step, int lt_offset, int rows, int cols, |
||||
__global const float* lf, __global float* dst, float step_size) |
||||
{ |
||||
/* The labeling scheme for this five star stencil: |
||||
[ a ] |
||||
[ -1 c +1 ] |
||||
[ b ] |
||||
*/ |
||||
// column-first indexing |
||||
int i = get_global_id(1); |
||||
int j = get_global_id(0); |
||||
|
||||
// OpenCV plays with dimensions so we need explicit check for this |
||||
if (!(i < rows && j < cols)) |
||||
{ |
||||
return; |
||||
} |
||||
|
||||
// get row indexes |
||||
int a = (i - 1) * cols; |
||||
int c = (i ) * cols; |
||||
int b = (i + 1) * cols; |
||||
// compute stencil |
||||
float res = 0.0f; |
||||
if (i == 0) // first rows |
||||
{ |
||||
if (j == 0 || j == (cols - 1)) |
||||
{ |
||||
res = 0.0f; |
||||
} else |
||||
{ |
||||
res = (lf[c + j] + lf[c + j + 1])*(lt[c + j + 1] - lt[c + j]) + |
||||
(lf[c + j] + lf[c + j - 1])*(lt[c + j - 1] - lt[c + j]) + |
||||
(lf[c + j] + lf[b + j ])*(lt[b + j ] - lt[c + j]); |
||||
} |
||||
} else if (i == (rows - 1)) // last row |
||||
{ |
||||
if (j == 0 || j == (cols - 1)) |
||||
{ |
||||
res = 0.0f; |
||||
} else |
||||
{ |
||||
res = (lf[c + j] + lf[c + j + 1])*(lt[c + j + 1] - lt[c + j]) + |
||||
(lf[c + j] + lf[c + j - 1])*(lt[c + j - 1] - lt[c + j]) + |
||||
(lf[c + j] + lf[a + j ])*(lt[a + j ] - lt[c + j]); |
||||
} |
||||
} else // inner rows |
||||
{ |
||||
if (j == 0) // first column |
||||
{ |
||||
res = (lf[c + 0] + lf[c + 1])*(lt[c + 1] - lt[c + 0]) + |
||||
(lf[c + 0] + lf[b + 0])*(lt[b + 0] - lt[c + 0]) + |
||||
(lf[c + 0] + lf[a + 0])*(lt[a + 0] - lt[c + 0]); |
||||
} else if (j == (cols - 1)) // last column |
||||
{ |
||||
res = (lf[c + j] + lf[c + j - 1])*(lt[c + j - 1] - lt[c + j]) + |
||||
(lf[c + j] + lf[b + j ])*(lt[b + j ] - lt[c + j]) + |
||||
(lf[c + j] + lf[a + j ])*(lt[a + j ] - lt[c + j]); |
||||
} else // inner stencil |
||||
{ |
||||
res = (lf[c + j] + lf[c + j + 1])*(lt[c + j + 1] - lt[c + j]) + |
||||
(lf[c + j] + lf[c + j - 1])*(lt[c + j - 1] - lt[c + j]) + |
||||
(lf[c + j] + lf[b + j ])*(lt[b + j ] - lt[c + j]) + |
||||
(lf[c + j] + lf[a + j ])*(lt[a + j ] - lt[c + j]); |
||||
} |
||||
} |
||||
|
||||
dst[c + j] = res * step_size; |
||||
} |
||||
|
||||
/** |
||||
* @brief Compute determinant from hessians |
||||
* @details Compute Ldet by (Lxx.mul(Lyy) - Lxy.mul(Lxy)) * sigma |
||||
* |
||||
* @param lxx spatial derivates |
||||
* @param lxy spatial derivates |
||||
* @param lyy spatial derivates |
||||
* @param dst output determinant |
||||
* @param sigma determinant will be scaled by this sigma |
||||
*/ |
||||
__kernel void |
||||
AKAZE_compute_determinant(__global const float* lxx, __global const float* lxy, __global const float* lyy, |
||||
__global float* dst, float sigma, int size) |
||||
{ |
||||
int i = get_global_id(0); |
||||
// OpenCV plays with dimensions so we need explicit check for this |
||||
if (!(i < size)) |
||||
{ |
||||
return; |
||||
} |
||||
|
||||
dst[i] = (lxx[i] * lyy[i] - lxy[i] * lxy[i]) * sigma; |
||||
} |
||||
@ -0,0 +1,47 @@ |
||||
// This file is part of OpenCV project.
|
||||
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||
// of this distribution and at http://opencv.org/license.html
|
||||
|
||||
#include "test_precomp.hpp" |
||||
|
||||
using namespace std; |
||||
using namespace cv; |
||||
|
||||
TEST(Features2d_AKAZE, detect_and_compute_split) |
||||
{ |
||||
Mat testImg(100, 100, CV_8U); |
||||
RNG rng(101); |
||||
rng.fill(testImg, RNG::UNIFORM, Scalar(0), Scalar(255), true); |
||||
|
||||
Ptr<Feature2D> ext = AKAZE::create(AKAZE::DESCRIPTOR_MLDB, 0, 3, 0.001f, 1, 1, KAZE::DIFF_PM_G2); |
||||
vector<KeyPoint> detAndCompKps; |
||||
Mat desc; |
||||
ext->detectAndCompute(testImg, noArray(), detAndCompKps, desc); |
||||
|
||||
vector<KeyPoint> detKps; |
||||
ext->detect(testImg, detKps); |
||||
|
||||
ASSERT_EQ(detKps.size(), detAndCompKps.size()); |
||||
|
||||
for(size_t i = 0; i < detKps.size(); i++) |
||||
ASSERT_EQ(detKps[i].hash(), detAndCompKps[i].hash()); |
||||
} |
||||
|
||||
/**
|
||||
* This test is here to guard propagation of NaNs that happens on this image. NaNs are guarded |
||||
* by debug asserts in AKAZE, which should fire for you if you are lucky. |
||||
* |
||||
* This test also reveals problems with uninitialized memory that happens only on this image. |
||||
* This is very hard to hit and depends a lot on particular allocator. Run this test in valgrind and check |
||||
* for uninitialized values if you think you are hitting this problem again. |
||||
*/ |
||||
TEST(Features2d_AKAZE, uninitialized_and_nans) |
||||
{ |
||||
Mat b1 = imread(cvtest::TS::ptr()->get_data_path() + "../stitching/b1.png"); |
||||
ASSERT_FALSE(b1.empty()); |
||||
|
||||
vector<KeyPoint> keypoints; |
||||
Mat desc; |
||||
Ptr<Feature2D> akaze = AKAZE::create(); |
||||
akaze->detectAndCompute(b1, noArray(), keypoints, desc); |
||||
} |
||||
Loading…
Reference in new issue