vendor: OpenCV 5.0.0 snapshot at 755e50675d97db9b7d449d8bd6b09888646f6c6e

2026-08-22 00:11:13 +08:00
commit 12022378a3
3872 changed files with 2513409 additions and 0 deletions
@@ -0,0 +1,36 @@
+// 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 "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> beblid;
+
+#define BEBLID_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+#ifdef OPENCV_ENABLE_NONFREE
+PERF_TEST_P(beblid, extract, testing::Values(BEBLID_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<BEBLID> descriptor = BEBLID::create(6.25f);
+    cv::Mat descriptors;
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+#endif // NONFREE
+
+}} // namespace
@@ -0,0 +1,33 @@
+// 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 "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> daisy;
+
+#define DAISY_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(daisy, extract, testing::Values(DAISY_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<DAISY> descriptor = DAISY::create();
+
+    vector<KeyPoint> points;
+    Mat_<float> descriptors;
+    // compute all daisies in image
+    TEST_CYCLE() descriptor->compute(frame, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
@@ -0,0 +1,71 @@
+#include "perf_feature2d.hpp"
+
+namespace opencv_test
+{
+
+PERF_TEST_P(feature2d, detect, testing::Combine(Feature2DType::all(), TEST_IMAGES))
+{
+    Ptr<Feature2D> detector = getFeature2D(get<0>(GetParam()));
+    std::string filename = getDataPath(get<1>(GetParam()));
+    Mat img = imread(filename, IMREAD_GRAYSCALE);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(detector);
+
+    declare.in(img);
+    Mat mask;
+    vector<KeyPoint> points;
+
+    TEST_CYCLE() detector->detect(img, points, mask);
+
+    EXPECT_GT(points.size(), 20u);
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(feature2d, extract, testing::Combine(testing::Values(DETECTORS_EXTRACTORS), TEST_IMAGES))
+{
+    Ptr<Feature2D> detector = AKAZE::create();
+    Ptr<Feature2D> extractor = getFeature2D(get<0>(GetParam()));
+    std::string filename = getDataPath(get<1>(GetParam()));
+    Mat img = imread(filename, IMREAD_GRAYSCALE);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(extractor);
+
+    declare.in(img);
+    Mat mask;
+    vector<KeyPoint> points;
+    detector->detect(img, points, mask);
+
+    EXPECT_GT(points.size(), 20u);
+
+    Mat descriptors;
+
+    TEST_CYCLE() extractor->compute(img, points, descriptors);
+
+    EXPECT_EQ((size_t)descriptors.rows, points.size());
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(feature2d, detectAndExtract, testing::Combine(testing::Values(DETECTORS_EXTRACTORS), TEST_IMAGES))
+{
+    Ptr<Feature2D> detector = getFeature2D(get<0>(GetParam()));
+    std::string filename = getDataPath(get<1>(GetParam()));
+    Mat img = imread(filename, IMREAD_GRAYSCALE);
+
+    ASSERT_FALSE(img.empty());
+    ASSERT_TRUE(detector);
+
+    declare.in(img);
+    Mat mask;
+    vector<KeyPoint> points;
+    Mat descriptors;
+
+    TEST_CYCLE() detector->detectAndCompute(img, mask, points, descriptors, false);
+
+    EXPECT_GT(points.size(), 20u);
+    EXPECT_EQ((size_t)descriptors.rows, points.size());
+    SANITY_CHECK_NOTHING();
+}
+
+} // namespace
@@ -0,0 +1,60 @@
+#ifndef __OPENCV_PERF_FEATURE2D_HPP__
+#define __OPENCV_PERF_FEATURE2D_HPP__
+
+#include "perf_precomp.hpp"
+
+namespace opencv_test {
+
+/* configuration for tests of detectors/descriptors. shared between ocl and cpu tests. */
+
+// detectors/descriptors configurations to test
+#define DETECTORS_ONLY                                                                  \
+    AGAST_DEFAULT, AGAST_5_8, AGAST_7_12d, AGAST_7_12s, AGAST_OAST_9_16
+
+#define DETECTORS_EXTRACTORS                                                            \
+    AKAZE_DEFAULT, AKAZE_DESCRIPTOR_KAZE,                                               \
+    BRISK_DEFAULT,                                                                      \
+    KAZE_DEFAULT
+
+#define CV_ENUM_EXPAND(name, ...) CV_ENUM(name, __VA_ARGS__)
+
+enum Feature2DVals { DETECTORS_ONLY, DETECTORS_EXTRACTORS };
+CV_ENUM_EXPAND(Feature2DType, DETECTORS_ONLY, DETECTORS_EXTRACTORS)
+
+typedef tuple<Feature2DType, string> Feature2DType_String_t;
+typedef perf::TestBaseWithParam<Feature2DType_String_t> feature2d;
+
+#define TEST_IMAGES testing::Values(\
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png", \
+    "stitching/s2.jpg")
+
+static inline Ptr<Feature2D> getFeature2D(Feature2DType type)
+{
+    switch(type) {
+    case AGAST_DEFAULT:
+        return AgastFeatureDetector::create();
+    case AGAST_5_8:
+        return AgastFeatureDetector::create(70, true, AgastFeatureDetector::AGAST_5_8);
+    case AGAST_7_12d:
+        return AgastFeatureDetector::create(70, true, AgastFeatureDetector::AGAST_7_12d);
+    case AGAST_7_12s:
+        return AgastFeatureDetector::create(70, true, AgastFeatureDetector::AGAST_7_12s);
+    case AGAST_OAST_9_16:
+        return AgastFeatureDetector::create(70, true, AgastFeatureDetector::OAST_9_16);
+    case AKAZE_DEFAULT:
+        return AKAZE::create();
+    case AKAZE_DESCRIPTOR_KAZE:
+        return AKAZE::create(AKAZE::DESCRIPTOR_KAZE);
+    case BRISK_DEFAULT:
+        return BRISK::create();
+    case KAZE_DEFAULT:
+        return KAZE::create();
+    default:
+        return Ptr<Feature2D>();
+    }
+}
+
+} // namespace
+
+#endif // __OPENCV_PERF_FEATURE2D_HPP__
@@ -0,0 +1,81 @@
+#include "perf_precomp.hpp"
+#include "opencv2/ts/ocl_perf.hpp"
+#include "perf_feature2d.hpp"
+
+#ifdef HAVE_OPENCL
+
+namespace opencv_test {
+namespace ocl {
+
+OCL_PERF_TEST_P(feature2d, detect, testing::Combine(Feature2DType::all(), TEST_IMAGES))
+{
+    Ptr<Feature2D> detector = getFeature2D(get<0>(GetParam()));
+    std::string filename = getDataPath(get<1>(GetParam()));
+    Mat mimg = imread(filename, IMREAD_GRAYSCALE);
+
+    ASSERT_FALSE(mimg.empty());
+    ASSERT_TRUE(detector);
+
+    UMat img, mask;
+    mimg.copyTo(img);
+    declare.in(img);
+    vector<KeyPoint> points;
+
+    OCL_TEST_CYCLE() detector->detect(img, points, mask);
+
+    EXPECT_GT(points.size(), 20u);
+    SANITY_CHECK_NOTHING();
+}
+
+OCL_PERF_TEST_P(feature2d, extract, testing::Combine(testing::Values(DETECTORS_EXTRACTORS), TEST_IMAGES))
+{
+    Ptr<Feature2D> detector = AKAZE::create();
+    Ptr<Feature2D> extractor = getFeature2D(get<0>(GetParam()));
+    std::string filename = getDataPath(get<1>(GetParam()));
+    Mat mimg = imread(filename, IMREAD_GRAYSCALE);
+
+    ASSERT_FALSE(mimg.empty());
+    ASSERT_TRUE(extractor);
+
+    UMat img, mask;
+    mimg.copyTo(img);
+    declare.in(img);
+    vector<KeyPoint> points;
+    detector->detect(img, points, mask);
+
+    EXPECT_GT(points.size(), 20u);
+
+    UMat descriptors;
+
+    OCL_TEST_CYCLE() extractor->compute(img, points, descriptors);
+
+    EXPECT_EQ((size_t)descriptors.rows, points.size());
+    SANITY_CHECK_NOTHING();
+}
+
+OCL_PERF_TEST_P(feature2d, detectAndExtract, testing::Combine(testing::Values(DETECTORS_EXTRACTORS), TEST_IMAGES))
+{
+    Ptr<Feature2D> detector = getFeature2D(get<0>(GetParam()));
+    std::string filename = getDataPath(get<1>(GetParam()));
+    Mat mimg = imread(filename, IMREAD_GRAYSCALE);
+
+    ASSERT_FALSE(mimg.empty());
+    ASSERT_TRUE(detector);
+
+    UMat img, mask;
+    mimg.copyTo(img);
+    declare.in(img);
+    vector<KeyPoint> points;
+    UMat descriptors;
+
+    OCL_TEST_CYCLE() detector->detectAndCompute(img, mask, points, descriptors, false);
+
+    EXPECT_GT(points.size(), 20u);
+    EXPECT_EQ((size_t)descriptors.rows, points.size());
+    SANITY_CHECK_NOTHING();
+}
+
+} // ocl
+} // cvtest
+
+#endif // HAVE_OPENCL
@@ -0,0 +1,36 @@
+// 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 "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> latch;
+
+#define LATCH_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+#ifdef OPENCV_ENABLE_NONFREE
+PERF_TEST_P(latch, extract, testing::Values(LATCH_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<LATCH> descriptor = LATCH::create();
+    vector<uchar> descriptors;
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+#endif // NONFREE
+
+}} // namespace
@@ -0,0 +1,14 @@
+// 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 "perf_precomp.hpp"
+#include "opencv2/ts/cuda_perf.hpp"
+
+static const char * impls[] = {
+#ifdef HAVE_CUDA
+    "cuda",
+#endif
+    "plain"
+};
+
+CV_PERF_TEST_MAIN_WITH_IMPLS(xfeatures2d, impls, perf::printCudaInfo())
@@ -0,0 +1,33 @@
+// 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 "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> msd;
+
+#define MSD_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(msd, detect, testing::Values(MSD_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+
+    if (frame.empty())
+        FAIL() << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame);
+    Ptr<MSDDetector> detector = MSDDetector::create();
+    vector<KeyPoint> points;
+
+    TEST_CYCLE() detector->detect(frame, points, mask);
+
+    sort(points.begin(), points.end(), comparators::KeypointGreater());
+    SANITY_CHECK_KEYPOINTS(points, 1e-3);
+}
+
+}} // namespace
@@ -0,0 +1,25 @@
+// 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.
+#ifndef __OPENCV_PERF_PRECOMP_HPP__
+#define __OPENCV_PERF_PRECOMP_HPP__
+
+#include "cvconfig.h"
+
+#include "opencv2/ts.hpp"
+#include "opencv2/xfeatures2d.hpp"
+
+#ifdef HAVE_OPENCV_OCL
+#  include "opencv2/ocl.hpp"
+#endif
+
+#ifdef HAVE_CUDA
+#  include "opencv2/xfeatures2d/cuda.hpp"
+#endif
+
+namespace opencv_test {
+using namespace cv::xfeatures2d;
+using namespace perf;
+}
+
+#endif
@@ -0,0 +1,68 @@
+// 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 "perf_precomp.hpp"
+
+#ifdef OPENCV_ENABLE_NONFREE
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> surf;
+
+#define SURF_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(surf, detect, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+
+    TEST_CYCLE() detector->detect(frame, points, mask);
+
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(surf, extract, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    Mat descriptors;
+    detector->detect(frame, points, mask);
+
+    TEST_CYCLE() detector->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(surf, full, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    Mat descriptors;
+
+    TEST_CYCLE() detector->detectAndCompute(frame, mask, points, descriptors, false);
+
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
+#endif // NONFREE
@@ -0,0 +1,102 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+#if defined(HAVE_CUDA) && defined(OPENCV_ENABLE_NONFREE)
+
+#include "opencv2/ts/cuda_perf.hpp"
+
+namespace opencv_test { namespace {
+
+//////////////////////////////////////////////////////////////////////
+// SURF
+
+#ifdef HAVE_OPENCV_CUDAARITHM
+
+DEF_PARAM_TEST_1(Image, string);
+
+PERF_TEST_P(Image, CUDA_SURF,
+            Values<std::string>("gpu/perf/aloe.png"))
+{
+    declare.time(50.0);
+
+    const cv::Mat img = readImage(GetParam(), cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    if (PERF_RUN_CUDA())
+    {
+        cv::cuda::SURF_CUDA d_surf;
+
+        const cv::cuda::GpuMat d_img(img);
+        cv::cuda::GpuMat d_keypoints, d_descriptors;
+
+        TEST_CYCLE() d_surf(d_img, cv::cuda::GpuMat(), d_keypoints, d_descriptors);
+
+        std::vector<cv::KeyPoint> gpu_keypoints;
+        d_surf.downloadKeypoints(d_keypoints, gpu_keypoints);
+
+        cv::Mat gpu_descriptors(d_descriptors);
+
+        sortKeyPoints(gpu_keypoints, gpu_descriptors);
+
+        SANITY_CHECK_KEYPOINTS(gpu_keypoints);
+        SANITY_CHECK(gpu_descriptors, 1e-3);
+    }
+    else
+    {
+        cv::Ptr<cv::Feature2D> surf = cv::xfeatures2d::SURF::create();
+        std::vector<cv::KeyPoint> cpu_keypoints;
+        cv::Mat cpu_descriptors;
+
+        TEST_CYCLE() surf->detect(img, cpu_keypoints);
+        TEST_CYCLE() surf->compute(img, cpu_keypoints, cpu_descriptors);
+
+        SANITY_CHECK_KEYPOINTS(cpu_keypoints);
+        SANITY_CHECK(cpu_descriptors);
+    }
+}
+
+#endif // HAVE_OPENCV_CUDAARITHM
+
+}} // namespace
+#endif // HAVE_CUDA && OPENCV_ENABLE_NONFREE
@@ -0,0 +1,108 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved.
+// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// @Authors
+//    Peng Xiao, pengxiao@multicorewareinc.com
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors as is and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "perf_precomp.hpp"
+
+#if defined(HAVE_OPENCV_OCL) && defined(OPENCV_ENABLE_NONFREE)
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> OCL_SURF;
+
+#define SURF_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(OCL_SURF, DISABLED_with_data_transfer, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat img = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    SURF_OCL d_surf;
+    oclMat d_keypoints;
+    oclMat d_descriptors;
+    Mat cpu_kp;
+    Mat cpu_dp;
+
+    declare.time(60);
+
+    TEST_CYCLE()
+    {
+        oclMat d_src(img);
+
+        d_surf(d_src, oclMat(), d_keypoints, d_descriptors);
+
+        d_keypoints.download(cpu_kp);
+        d_descriptors.download(cpu_dp);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P(OCL_SURF, DISABLED_without_data_transfer, testing::Values(SURF_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat img = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    SURF_OCL d_surf;
+    oclMat d_keypoints;
+    oclMat d_descriptors;
+    oclMat d_src(img);
+
+    declare.time(60);
+
+    TEST_CYCLE() d_surf(d_src, oclMat(), d_keypoints, d_descriptors);
+
+    Mat cpu_kp;
+    Mat cpu_dp;
+    d_keypoints.download(cpu_kp);
+    d_descriptors.download(cpu_dp);
+    SANITY_CHECK_NOTHING();
+}
+
+}} // namespace
+#endif // HAVE_OPENCV_OCL && OPENCV_ENABLE_NONFREE
@@ -0,0 +1,36 @@
+// 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 "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+typedef perf::TestBaseWithParam<std::string> teblid;
+
+#define TEBLID_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+#ifdef OPENCV_ENABLE_NONFREE
+PERF_TEST_P(teblid, extract, testing::Values(TEBLID_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<SURF> detector = SURF::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<TEBLID> descriptor = TEBLID::create(6.25f);
+    cv::Mat descriptors;
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+#endif // NONFREE
+
+}} // namespace
@@ -0,0 +1,39 @@
+// 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 "perf_precomp.hpp"
+
+namespace opencv_test { namespace {
+
+#ifdef OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+typedef perf::TestBaseWithParam<std::string> vgg;
+
+#define VGG_IMAGES \
+    "cv/detectors_descriptors_evaluation/images_datasets/leuven/img1.png",\
+    "stitching/a3.png"
+
+PERF_TEST_P(vgg, extract, testing::Values(VGG_IMAGES))
+{
+    string filename = getDataPath(GetParam());
+    Mat frame = imread(filename, IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame.empty()) << "Unable to load source image " << filename;
+
+    Mat mask;
+    declare.in(frame).time(90);
+
+    Ptr<KAZE> detector = KAZE::create();
+    vector<KeyPoint> points;
+    detector->detect(frame, points, mask);
+
+    Ptr<VGG> descriptor = VGG::create();
+    Mat_<float> descriptors;
+    // compute keypoints descriptor
+    TEST_CYCLE() descriptor->compute(frame, points, descriptors);
+
+    SANITY_CHECK_NOTHING();
+}
+
+#endif  // OPENCV_XFEATURES2D_HAS_VGG_DATA
+
+}} // namespace