reworked nearly all of the OpenCV tests (except for opencv_gpu tests) - they now use the Google Test engine.

modules/features2d/test/test_bruteforcematcher.cpp

@@ -0,0 +1,122 @@
+#include "test_precomp.hpp"
+
+#if 0
+using namespace cv;
+
+class BruteForceMatcherTest : public cvtest::BaseTest
+{
+public:
+    BruteForceMatcherTest();
+protected:
+    void run( int );
+};
+
+struct CV_EXPORTS L2Fake : public L2<float>
+{
+};
+
+BruteForceMatcherTest::BruteForceMatcherTest() : cvtest::BaseTest( "BruteForceMatcher", "BruteForceMatcher::matchImpl")
+{
+    support_testing_modes = cvtest::TS::TIMING_MODE;
+}
+
+void BruteForceMatcherTest::run( int )
+{
+    const int dimensions = 64;
+    const int descriptorsNumber = 5000;
+
+    Mat train = Mat( descriptorsNumber, dimensions, CV_32FC1);
+    Mat query = Mat( descriptorsNumber, dimensions, CV_32FC1);
+
+    Mat permutation( 1, descriptorsNumber, CV_32SC1 );
+    for( int i=0;i<descriptorsNumber;i++ )
+        permutation.at<int>( 0, i ) = i;
+
+    //RNG rng = RNG( cvGetTickCount() );
+    RNG rng = RNG( *ts->get_rng() );
+    randShuffle( permutation, 1, &rng );
+
+    float boundary =  500.f;
+    for( int row=0;row<descriptorsNumber;row++ )
+    {
+        for( int col=0;col<dimensions;col++ )
+        {
+            int bit = rng( 2 );
+            train.at<float>( permutation.at<int>( 0, row ), col ) = bit*boundary + rng.uniform( 0.f, boundary );
+            query.at<float>( row, col ) = bit*boundary + rng.uniform( 0.f, boundary );
+        }
+    }
+
+    vector<DMatch> specMatches, genericMatches;
+    BruteForceMatcher<L2<float> > specMatcher;
+    BruteForceMatcher<L2Fake > genericMatcher;
+
+    int64 time0 = cvGetTickCount();
+    specMatcher.match( query, train, specMatches );
+    int64 time1 = cvGetTickCount();
+    genericMatcher.match( query, train, genericMatches );
+    int64 time2 = cvGetTickCount();
+
+    float specMatcherTime = float(time1 - time0)/(float)cvGetTickFrequency();
+    ts->printf( cvtest::TS::LOG, "Matching by matrix multiplication time s: %f, us per pair: %f\n",
+               specMatcherTime*1e-6, specMatcherTime/( descriptorsNumber*descriptorsNumber ) );
+
+    float genericMatcherTime = float(time2 - time1)/(float)cvGetTickFrequency();
+    ts->printf( cvtest::TS::LOG, "Matching without matrix multiplication time s: %f, us per pair: %f\n",
+               genericMatcherTime*1e-6, genericMatcherTime/( descriptorsNumber*descriptorsNumber ) );
+
+    if( (int)specMatches.size() != descriptorsNumber || (int)genericMatches.size() != descriptorsNumber )
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
+    for( int i=0;i<descriptorsNumber;i++ )
+    {
+        float epsilon = 0.01f;
+        bool isEquiv = fabs( specMatches[i].distance - genericMatches[i].distance ) < epsilon &&
+                       specMatches[i].queryIdx == genericMatches[i].queryIdx &&
+                       specMatches[i].trainIdx == genericMatches[i].trainIdx;
+        if( !isEquiv || specMatches[i].trainIdx != permutation.at<int>( 0, i ) )
+        {
+            ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH );
+            break;
+        }
+    }
+
+
+    //Test mask
+    Mat mask( query.rows, train.rows, CV_8UC1 );
+    rng.fill( mask, RNG::UNIFORM, 0, 2 );
+
+
+    time0 = cvGetTickCount();
+    specMatcher.match( query, train, specMatches, mask );
+    time1 = cvGetTickCount();
+    genericMatcher.match( query, train, genericMatches, mask );
+    time2 = cvGetTickCount();
+
+    specMatcherTime = float(time1 - time0)/(float)cvGetTickFrequency();
+    ts->printf( cvtest::TS::LOG, "Matching by matrix multiplication time with mask s: %f, us per pair: %f\n",
+               specMatcherTime*1e-6, specMatcherTime/( descriptorsNumber*descriptorsNumber ) );
+
+    genericMatcherTime = float(time2 - time1)/(float)cvGetTickFrequency();
+    ts->printf( cvtest::TS::LOG, "Matching without matrix multiplication time with mask s: %f, us per pair: %f\n",
+               genericMatcherTime*1e-6, genericMatcherTime/( descriptorsNumber*descriptorsNumber ) );
+
+    if( specMatches.size() != genericMatches.size() )
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
+
+    for( size_t i=0;i<specMatches.size();i++ )
+    {
+        //float epsilon = 1e-2;
+        float epsilon = 10000000;
+        bool isEquiv = fabs( specMatches[i].distance - genericMatches[i].distance ) < epsilon &&
+                       specMatches[i].queryIdx == genericMatches[i].queryIdx &&
+                       specMatches[i].trainIdx == genericMatches[i].trainIdx;
+        if( !isEquiv )
+        {
+            ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH );
+            break;
+        }
+    }
+}
+
+BruteForceMatcherTest taBruteForceMatcherTest;
+#endif

modules/features2d/test/test_detectors.cpp

@@ -0,0 +1,317 @@
+/*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 "test_precomp.hpp"
+
+#include <string>
+#include <iostream>
+#include <iterator>
+#include <fstream>
+#include <numeric>
+#include <algorithm>
+#include <iterator>
+
+using namespace cv;
+using namespace std;
+
+class CV_DetectorsTest : public cvtest::BaseTest
+{
+public:
+    CV_DetectorsTest();
+    ~CV_DetectorsTest();    
+protected:    
+    void run(int);  
+    template <class T> bool testDetector(const Mat& img, const T& detector, vector<KeyPoint>& expected);
+
+    void LoadExpected(const string& file, vector<KeyPoint>& out);
+};
+
+CV_DetectorsTest::CV_DetectorsTest()
+{
+}
+CV_DetectorsTest::~CV_DetectorsTest() {}
+
+void getRotation(const Mat& img, Mat& aff, Mat& out)
+{
+    Point center(img.cols/2, img.rows/2);
+    aff = getRotationMatrix2D(center, 30, 1);
+    warpAffine( img, out, aff, img.size());
+}
+
+void getZoom(const Mat& img, Mat& aff, Mat& out)
+{
+    const double mult = 1.2;
+
+    aff.create(2, 3, CV_64F);
+    double *data = aff.ptr<double>();
+    data[0] = mult; data[1] =    0; data[2] = 0;
+    data[3] =    0; data[4] = mult; data[5] = 0;
+    
+    warpAffine( img, out, aff, img.size());
+}
+
+void getBlur(const Mat& img, Mat& aff, Mat& out)
+{        
+    aff.create(2, 3, CV_64F);
+    double *data = aff.ptr<double>();
+    data[0] = 1; data[1] = 0; data[2] = 0;
+    data[3] = 0; data[4] = 1; data[5] = 0;
+        
+    GaussianBlur(img, out, Size(5, 5), 2);    
+}
+
+void getBrightness(const Mat& img, Mat& aff, Mat& out)
+{        
+    aff.create(2, 3, CV_64F);
+    double *data = aff.ptr<double>();
+    data[0] = 1; data[1] = 0; data[2] = 0;
+    data[3] = 0; data[4] = 1; data[5] = 0;
+        
+    add(img, Mat(img.size(), img.type(), Scalar(15)), out);    
+}
+
+void showOrig(const Mat& img, const vector<KeyPoint>& orig_pts)
+{
+      
+    Mat img_color;
+    cvtColor(img, img_color, CV_GRAY2BGR); 
+    
+    for(size_t i = 0; i < orig_pts.size(); ++i)    
+        circle(img_color, orig_pts[i].pt, (int)orig_pts[i].size/2, CV_RGB(0, 255, 0));                        
+    
+    namedWindow("O"); imshow("O", img_color);     
+}
+
+void show(const string& name, const Mat& new_img, const vector<KeyPoint>& new_pts, const vector<KeyPoint>& transf_pts)
+{
+      
+    Mat new_img_color;    
+    cvtColor(new_img, new_img_color, CV_GRAY2BGR); 
+
+    for(size_t i = 0; i < transf_pts.size(); ++i)
+        circle(new_img_color, transf_pts[i].pt, (int)transf_pts[i].size/2, CV_RGB(255, 0, 0));
+
+    for(size_t i = 0; i < new_pts.size(); ++i)    
+        circle(new_img_color, new_pts[i].pt, (int)new_pts[i].size/2, CV_RGB(0, 0, 255));
+    
+    namedWindow(name + "_T"); imshow(name + "_T", new_img_color); 
+}
+
+struct WrapPoint
+{
+    const double* R;
+    WrapPoint(const Mat& rmat) : R(rmat.ptr<double>()) { };
+    
+    KeyPoint operator()(const KeyPoint& kp) const 
+    {                
+        KeyPoint res = kp;
+        res.pt.x = static_cast<float>(kp.pt.x * R[0] + kp.pt.y * R[1] + R[2]);
+        res.pt.y = static_cast<float>(kp.pt.x * R[3] + kp.pt.y * R[4] + R[5]);                
+        return res;                             
+    }
+};
+
+struct sortByR { bool operator()(const KeyPoint& kp1, const KeyPoint& kp2) { return norm(kp1.pt) < norm(kp2.pt); } };
+
+template <class T> bool CV_DetectorsTest::testDetector(const Mat& img, const T& detector, vector<KeyPoint>& exp)
+{
+    vector<KeyPoint> orig_kpts;
+    detector(img, orig_kpts);
+
+    typedef void (*TransfFunc )(const Mat&, Mat&, Mat& FransfFunc);    
+    const TransfFunc transfFunc[] = { getRotation, getZoom, getBlur, getBrightness };
+    //const string names[] =  { "Rotation", "Zoom", "Blur", "Brightness" };
+    const size_t case_num = sizeof(transfFunc)/sizeof(transfFunc[0]);
+
+    vector<Mat> affs(case_num);
+    vector<Mat> new_imgs(case_num);
+
+    vector< vector<KeyPoint> > new_kpts(case_num);
+    vector< vector<KeyPoint> > transf_kpts(case_num);
+
+    //showOrig(img, orig_kpts);
+    for(size_t i = 0; i < case_num; ++i)   
+    {
+        transfFunc[i](img, affs[i], new_imgs[i]);
+        detector(new_imgs[i], new_kpts[i]);
+        transform(orig_kpts.begin(), orig_kpts.end(), back_inserter(transf_kpts[i]), WrapPoint(affs[i]));
+        //show(names[i], new_imgs[i], new_kpts[i], transf_kpts[i]);
+    }
+
+    const float thres = 3;
+    const float nthres = 3;
+
+    vector<KeyPoint> result;
+    for(size_t i = 0; i < orig_kpts.size(); ++i)
+    {
+        const KeyPoint& okp = orig_kpts[i];
+        int foundCounter = 0;
+        for(size_t j = 0; j < case_num; ++j)
+        {            
+            const KeyPoint& tkp = transf_kpts[j][i];
+
+            size_t k = 0;
+            
+            for(; k < new_kpts[j].size(); ++k)
+                if (norm(new_kpts[j][k].pt - tkp.pt) < nthres && fabs(new_kpts[j][k].size - tkp.size) < thres)
+                    break;
+
+            if (k != new_kpts[j].size())
+                ++foundCounter;
+
+        }
+        if (foundCounter == (int)case_num)
+            result.push_back(okp);
+    }
+
+    sort(result.begin(), result.end(), sortByR());
+    sort(exp.begin(), exp.end(), sortByR());
+
+    if (result.size() != exp.size())
+    {
+      ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA);
+      return false;
+    }
+
+    int foundCounter1 = 0;
+    for(size_t i = 0; i < exp.size(); ++i)
+    {
+        const KeyPoint& e = exp[i];                
+        size_t j = 0;
+        for(; j < result.size(); ++j)
+        {
+            const KeyPoint& r = result[i];
+            if (norm(r.pt-e.pt) < nthres && fabs(r.size - e.size) < thres)
+                break;
+        }
+        if (j != result.size())
+            ++foundCounter1;
+    }
+
+    int foundCounter2 = 0;
+    for(size_t i = 0; i < result.size(); ++i)
+    {
+        const KeyPoint& r = result[i];                
+        size_t j = 0;
+        for(; j < exp.size(); ++j)
+        {
+            const KeyPoint& e = exp[i];
+            if (norm(r.pt-e.pt) < nthres && fabs(r.size - e.size) < thres)
+                break;
+        }
+        if (j != exp.size())
+            ++foundCounter2;
+    }
+    //showOrig(img, result); waitKey();
+
+    const float errorRate = 0.9f;
+    if (float(foundCounter1)/exp.size() < errorRate || float(foundCounter2)/result.size() < errorRate)
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_MISMATCH);
+        return false;
+    }
+    return true;        
+}
+
+struct SurfNoMaskWrap 
+{
+    const SURF& detector;
+    SurfNoMaskWrap(const SURF& surf) : detector(surf) {}
+    SurfNoMaskWrap& operator=(const SurfNoMaskWrap&);
+    void operator()(const Mat& img, vector<KeyPoint>& kpts) const { detector(img, Mat(), kpts); }
+};
+
+void CV_DetectorsTest::LoadExpected(const string& file, vector<KeyPoint>& out)
+{     
+    Mat mat_exp;
+    FileStorage fs(file, FileStorage::READ);    
+    if (fs.isOpened())
+    {
+        read( fs["ResultVectorData"], mat_exp, Mat() );           
+        out.resize(mat_exp.cols / sizeof(KeyPoint));
+        copy(mat_exp.ptr<KeyPoint>(), mat_exp.ptr<KeyPoint>() + out.size(), out.begin());            
+    }
+    else
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA);
+        out.clear();
+    }    
+}
+
+void CV_DetectorsTest::run( int /*start_from*/ )
+{	         
+    Mat img = imread(string(ts->get_data_path()) + "shared/graffiti.png", 0);
+
+    if (img.empty())
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );
+        return;
+    }
+            
+    Mat to_test(img.size() * 2, img.type(), Scalar(0));
+    Mat roi = to_test(Rect(img.rows/2, img.cols/2, img.cols, img.rows));
+    img.copyTo(roi);
+    GaussianBlur(to_test, to_test, Size(3, 3), 1.5);
+        
+    vector<KeyPoint> exp;
+    LoadExpected(string(ts->get_data_path()) + "detectors/surf.xml", exp);        
+    if (exp.empty())
+        return;
+
+    if (!testDetector(to_test, SurfNoMaskWrap(SURF(1536+512+512, 2)), exp))
+        return;
+    
+    LoadExpected(string(ts->get_data_path()) + "detectors/star.xml", exp);
+    if (exp.empty())
+        return;
+
+    if (!testDetector(to_test, StarDetector(45, 30, 10, 8, 5), exp))
+        return;
+
+    ts->set_failed_test_info( cvtest::TS::OK);		   
+}
+
+
+TEST(Features2d_Detectors, regression) { CV_DetectorsTest test; test.safe_run(); }
+
+
+

modules/features2d/test/test_fast.cpp

@@ -0,0 +1,126 @@
+/*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 "test_precomp.hpp"
+
+using namespace cv;
+
+class CV_FastTest : public cvtest::BaseTest
+{
+public:
+    CV_FastTest();
+    ~CV_FastTest();    
+protected:    
+    void run(int);
+};
+
+CV_FastTest::CV_FastTest() {}
+CV_FastTest::~CV_FastTest() {}
+
+void CV_FastTest::run( int )
+{
+    Mat image1 = imread(string(ts->get_data_path()) + "inpaint/orig.jpg");   
+    Mat image2 = imread(string(ts->get_data_path()) + "cameracalibration/chess9.jpg");   
+    string xml = string(ts->get_data_path()) + "fast/result.xml";
+        
+    if (image1.empty() || image2.empty())
+    {
+        ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA );  
+        return;
+    }
+
+    Mat gray1, gray2;
+    cvtColor(image1, gray1, CV_BGR2GRAY);
+    cvtColor(image2, gray2, CV_BGR2GRAY);
+
+    vector<KeyPoint> keypoints1;
+    vector<KeyPoint> keypoints2;    
+    FAST(gray1, keypoints1, 30);
+    FAST(gray2, keypoints2, 30);
+
+    for(size_t i = 0; i < keypoints1.size(); ++i)
+    {
+        const KeyPoint& kp = keypoints1[i];
+        cv::circle(image1, kp.pt, cvRound(kp.size/2), CV_RGB(255, 0, 0));        
+    }
+
+    for(size_t i = 0; i < keypoints2.size(); ++i)
+    {
+        const KeyPoint& kp = keypoints2[i];
+        cv::circle(image2, kp.pt, cvRound(kp.size/2), CV_RGB(255, 0, 0));        
+    }
+
+    Mat kps1(1, (int)(keypoints1.size() * sizeof(KeyPoint)), CV_8U, &keypoints1[0]);
+    Mat kps2(1, (int)(keypoints2.size() * sizeof(KeyPoint)), CV_8U, &keypoints2[0]);
+
+    FileStorage fs(xml, FileStorage::READ);
+    if (!fs.isOpened())
+    {
+        fs.open(xml, FileStorage::WRITE);
+        fs << "exp_kps1" << kps1;
+        fs << "exp_kps2" << kps2;
+        fs.release();
+    }              
+
+    if (!fs.isOpened())
+        fs.open(xml, FileStorage::READ);
+ 
+    Mat exp_kps1, exp_kps2;        
+    read( fs["exp_kps1"], exp_kps1, Mat() );
+    read( fs["exp_kps2"], exp_kps2, Mat() );                
+    fs.release();
+
+    if ( 0 != norm(exp_kps1, kps1, NORM_L2) || 0 != norm(exp_kps2, kps2, NORM_L2))
+    {
+        ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
+        return;
+    }
+    
+ /*   cv::namedWindow("Img1"); cv::imshow("Img1", image1);
+    cv::namedWindow("Img2"); cv::imshow("Img2", image2);
+    cv::waitKey(0);*/
+
+    ts->set_failed_test_info(cvtest::TS::OK);
+}
+
+TEST(Features2d_FAST, regression) { CV_FastTest test; test.safe_run(); }
+

modules/features2d/test/test_main.cpp

@@ -0,0 +1,3 @@
+#include "test_precomp.hpp"
+
+CV_TEST_MAIN("cv")

modules/features2d/test/test_mser.cpp

@@ -0,0 +1,203 @@
+/*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 "test_precomp.hpp"
+
+#include <vector>
+#include <string>
+using namespace std;
+using namespace cv;
+
+class CV_MserTest : public cvtest::BaseTest
+{
+public:
+    CV_MserTest();  
+protected:    
+    void run(int);
+	int LoadBoxes(const char* path, vector<CvBox2D>& boxes);
+	int SaveBoxes(const char* path, const vector<CvBox2D>& boxes);
+	int CompareBoxes(const vector<CvBox2D>& boxes1,const vector<CvBox2D>& boxes2, float max_rel_diff = 0.01f);
+};
+
+CV_MserTest::CV_MserTest()
+{
+}
+
+int CV_MserTest::LoadBoxes(const char* path, vector<CvBox2D>& boxes)
+{
+	boxes.clear();
+	FILE* f = fopen(path,"r");
+
+	if (f==NULL)
+	{
+		return 0;
+	}
+	
+	while (!feof(f))
+	{
+		CvBox2D box;
+		fscanf(f,"%f,%f,%f,%f,%f\n",&box.angle,&box.center.x,&box.center.y,&box.size.width,&box.size.height);
+		boxes.push_back(box);
+	}
+	fclose(f);
+	return 1;
+}
+
+int CV_MserTest::SaveBoxes(const char* path, const vector<CvBox2D>& boxes)
+{
+	FILE* f = fopen(path,"w");
+	if (f==NULL)
+	{
+		return 0;
+	}
+	for (int i=0;i<(int)boxes.size();i++)
+	{
+		fprintf(f,"%f,%f,%f,%f,%f\n",boxes[i].angle,boxes[i].center.x,boxes[i].center.y,boxes[i].size.width,boxes[i].size.height);
+	}
+	fclose(f);
+	return 1;
+}
+
+int CV_MserTest::CompareBoxes(const vector<CvBox2D>& boxes1,const vector<CvBox2D>& boxes2, float max_rel_diff)
+{
+	if (boxes1.size() != boxes2.size())
+		return 0;
+
+	for (int i=0; i<(int)boxes1.size();i++)
+	{
+		float rel_diff;
+		if (!((boxes1[i].angle == 0.0f) && (abs(boxes2[i].angle) < max_rel_diff)))
+		{
+			rel_diff = abs(boxes1[i].angle-boxes2[i].angle)/abs(boxes1[i].angle);
+			if (rel_diff > max_rel_diff)
+				return i;
+		}
+
+		if (!((boxes1[i].center.x == 0.0f) && (abs(boxes2[i].center.x) < max_rel_diff)))
+		{
+			rel_diff = abs(boxes1[i].center.x-boxes2[i].center.x)/abs(boxes1[i].center.x);
+			if (rel_diff > max_rel_diff)
+				return i;
+		}
+
+		if (!((boxes1[i].center.y == 0.0f) && (abs(boxes2[i].center.y) < max_rel_diff)))
+		{
+			rel_diff = abs(boxes1[i].center.y-boxes2[i].center.y)/abs(boxes1[i].center.y);
+			if (rel_diff > max_rel_diff)
+				return i;
+		}
+		if (!((boxes1[i].size.width == 0.0f) && (abs(boxes2[i].size.width) < max_rel_diff)))
+		{
+			rel_diff = abs(boxes1[i].size.width-boxes2[i].size.width)/abs(boxes1[i].size.width);
+			if (rel_diff > max_rel_diff)
+			return i;
+		}
+
+		if (!((boxes1[i].size.height == 0.0f) && (abs(boxes2[i].size.height) < max_rel_diff)))
+		{
+			rel_diff = abs(boxes1[i].size.height-boxes2[i].size.height)/abs(boxes1[i].size.height);
+			if (rel_diff > max_rel_diff)
+				return i;
+		}
+	}
+
+	return -1;
+}
+
+void CV_MserTest::run(int)
+{
+	string image_path = string(ts->get_data_path()) + "mser/puzzle.png";
+
+	IplImage* img = cvLoadImage( image_path.c_str());
+	if (!img)
+	{
+		ts->printf( cvtest::TS::LOG, "Unable to open image mser/puzzle.png\n");
+		ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
+		return;
+	}
+
+	CvSeq* contours;
+	CvMemStorage* storage= cvCreateMemStorage();
+	IplImage* hsv = cvCreateImage( cvGetSize( img ), IPL_DEPTH_8U, 3 );
+	cvCvtColor( img, hsv, CV_BGR2YCrCb );
+	CvMSERParams params = cvMSERParams();//cvMSERParams( 5, 60, cvRound(.2*img->width*img->height), .25, .2 );
+	cvExtractMSER( hsv, NULL, &contours, storage, params );
+
+	vector<CvBox2D> boxes;
+	vector<CvBox2D> boxes_orig;
+	for ( int i = 0; i < contours->total; i++ )
+	{
+		CvContour* r = *(CvContour**)cvGetSeqElem( contours, i );
+		CvBox2D box = cvFitEllipse2( r );
+		box.angle=(float)CV_PI/2-box.angle;
+		boxes.push_back(box);			
+	}
+
+	string boxes_path = string(ts->get_data_path()) + "mser/boxes.txt";
+	
+	if (!LoadBoxes(boxes_path.c_str(),boxes_orig))
+	{
+		SaveBoxes(boxes_path.c_str(),boxes);
+		ts->printf( cvtest::TS::LOG, "Unable to open data file mser/boxes.txt\n");
+		ts->set_failed_test_info(cvtest::TS::FAIL_MISSING_TEST_DATA);
+		return;
+	}
+
+	const float dissimularity = 0.01f;
+	int n_box = CompareBoxes(boxes_orig,boxes,dissimularity);
+	if (n_box < 0)
+	{
+		ts->set_failed_test_info(cvtest::TS::OK);
+	}
+	else
+	{
+		ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
+		ts->printf( cvtest::TS::LOG, "Incorrect correspondence in %d box\n",n_box);
+	}
+
+	cvReleaseMemStorage(&storage);
+	cvReleaseImage(&hsv);
+	cvReleaseImage(&img);
+}
+
+TEST(Features2d_MSER, regression) { CV_MserTest test; test.safe_run(); }
+

modules/features2d/test/test_nearestneighbors.cpp

@@ -0,0 +1,523 @@
+/*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 "test_precomp.hpp"
+
+#include <algorithm>
+#include <vector>
+#include <iostream>
+
+using namespace cv;
+using namespace cv::flann;
+
+//--------------------------------------------------------------------------------
+class NearestNeighborTest : public cvtest::BaseTest
+{
+public:
+    NearestNeighborTest() {}
+protected:
+    static const int minValue = 0;
+    static const int maxValue = 1;
+    static const int dims = 30;
+    static const int featuresCount = 2000;
+    static const int K = 1; // * should also test 2nd nn etc.?
+
+
+    virtual void run( int start_from );
+    virtual void createModel( const Mat& data ) = 0;
+    virtual int findNeighbors( Mat& points, Mat& neighbors ) = 0;
+    virtual int checkGetPoins( const Mat& data );
+    virtual int checkFindBoxed();
+    virtual int checkFind( const Mat& data );
+    virtual void releaseModel() = 0;
+};
+
+int NearestNeighborTest::checkGetPoins( const Mat& )
+{
+   return cvtest::TS::OK;
+}
+
+int NearestNeighborTest::checkFindBoxed()
+{
+    return cvtest::TS::OK;
+}
+
+int NearestNeighborTest::checkFind( const Mat& data )
+{
+    int code = cvtest::TS::OK;
+    int pointsCount = 1000;
+    float noise = 0.2f;
+
+    RNG rng;
+    Mat points( pointsCount, dims, CV_32FC1 );
+    Mat results( pointsCount, K, CV_32SC1 );
+
+    std::vector<int> fmap( pointsCount );
+    for( int pi = 0; pi < pointsCount; pi++ )
+    {
+        int fi = rng.next() % featuresCount;
+        fmap[pi] = fi;
+        for( int d = 0; d < dims; d++ )
+            points.at<float>(pi, d) = data.at<float>(fi, d) + rng.uniform(0.0f, 1.0f) * noise;
+    }
+
+    code = findNeighbors( points, results );
+
+    if( code == cvtest::TS::OK )
+    {
+        int correctMatches = 0;
+        for( int pi = 0; pi < pointsCount; pi++ )
+        {
+            if( fmap[pi] == results.at<int>(pi, 0) )
+                correctMatches++;
+        }
+
+        double correctPerc = correctMatches / (double)pointsCount;
+        if (correctPerc < .75)
+        {
+            ts->printf( cvtest::TS::LOG, "correct_perc = %d\n", correctPerc );
+            code = cvtest::TS::FAIL_BAD_ACCURACY;
+        }
+    }
+
+    return code;
+}
+
+void NearestNeighborTest::run( int /*start_from*/ ) {
+    int code = cvtest::TS::OK, tempCode;
+    Mat desc( featuresCount, dims, CV_32FC1 );
+    randu( desc, Scalar(minValue), Scalar(maxValue) );
+
+    createModel( desc );
+    
+    tempCode = checkGetPoins( desc );
+    if( tempCode != cvtest::TS::OK )
+    {
+        ts->printf( cvtest::TS::LOG, "bad accuracy of GetPoints \n" );
+        code = tempCode;
+    }
+
+    tempCode = checkFindBoxed();
+    if( tempCode != cvtest::TS::OK )
+    {
+        ts->printf( cvtest::TS::LOG, "bad accuracy of FindBoxed \n" );
+        code = tempCode;
+    }
+
+    tempCode = checkFind( desc );
+    if( tempCode != cvtest::TS::OK )
+    {
+        ts->printf( cvtest::TS::LOG, "bad accuracy of Find \n" );
+        code = tempCode;
+    }
+    
+    releaseModel();
+    
+    ts->set_failed_test_info( code );
+}
+
+//--------------------------------------------------------------------------------
+class CV_LSHTest : public NearestNeighborTest
+{
+public:
+    CV_LSHTest() {}
+protected:
+    virtual void createModel( const Mat& data );
+    virtual int findNeighbors( Mat& points, Mat& neighbors );
+    virtual void releaseModel();
+    struct CvLSH* lsh;
+    CvMat desc;
+};
+
+void CV_LSHTest::createModel( const Mat& data )
+{
+    desc = data;
+    lsh = cvCreateMemoryLSH( data.cols, data.rows, 70, 20, CV_32FC1 );
+    cvLSHAdd( lsh, &desc );
+}
+
+int CV_LSHTest::findNeighbors( Mat& points, Mat& neighbors )
+{
+    const int emax = 20;
+    Mat dist( points.rows, neighbors.cols, CV_64FC1);
+    CvMat _dist = dist, _points = points, _neighbors = neighbors;
+    cvLSHQuery( lsh, &_points, &_neighbors, &_dist, neighbors.cols, emax );
+    return cvtest::TS::OK;
+}
+
+void CV_LSHTest::releaseModel()
+{
+    cvReleaseLSH( &lsh );
+}
+
+//--------------------------------------------------------------------------------
+class CV_FeatureTreeTest_C : public NearestNeighborTest
+{
+public:
+    CV_FeatureTreeTest_C() {}
+protected:
+    virtual int findNeighbors( Mat& points, Mat& neighbors );
+    virtual void releaseModel();
+    CvFeatureTree* tr;
+    CvMat desc;
+};
+
+int CV_FeatureTreeTest_C::findNeighbors( Mat& points, Mat& neighbors )
+{
+    const int emax = 20;
+    Mat dist( points.rows, neighbors.cols, CV_64FC1);
+    CvMat _dist = dist, _points = points, _neighbors = neighbors;
+    cvFindFeatures( tr, &_points, &_neighbors, &_dist, neighbors.cols, emax );
+    return cvtest::TS::OK;
+}
+
+void CV_FeatureTreeTest_C::releaseModel()
+{
+    cvReleaseFeatureTree( tr );
+}
+
+//--------------------------------------
+class CV_SpillTreeTest_C : public CV_FeatureTreeTest_C
+{
+public:
+    CV_SpillTreeTest_C() {}
+protected:
+    virtual void createModel( const Mat& data );
+};
+
+void CV_SpillTreeTest_C::createModel( const Mat& data )
+{
+    desc = data;
+    tr = cvCreateSpillTree( &desc );
+}
+
+//--------------------------------------
+class CV_KDTreeTest_C : public CV_FeatureTreeTest_C
+{
+public:
+    CV_KDTreeTest_C() {}
+protected:
+    virtual void createModel( const Mat& data );
+    virtual int checkFindBoxed();
+};
+
+void CV_KDTreeTest_C::createModel( const Mat& data )
+{
+    desc = data;
+    tr = cvCreateKDTree( &desc );
+}
+
+int CV_KDTreeTest_C::checkFindBoxed()
+{
+    Mat min(1, dims, CV_32FC1 ), max(1, dims, CV_32FC1 ), indices( 1, 1, CV_32SC1 );
+    float l = minValue, r = maxValue;
+    min.setTo(Scalar(l)), max.setTo(Scalar(r));
+    CvMat _min = min, _max = max, _indices = indices;
+    // TODO check indices
+    if( cvFindFeaturesBoxed( tr, &_min, &_max, &_indices ) != featuresCount )
+        return cvtest::TS::FAIL_BAD_ACCURACY;
+    return cvtest::TS::OK;
+}
+
+//--------------------------------------------------------------------------------
+class CV_KDTreeTest_CPP : public NearestNeighborTest
+{
+public:
+    CV_KDTreeTest_CPP() {}
+protected:
+    virtual void createModel( const Mat& data );
+    virtual int checkGetPoins( const Mat& data );
+    virtual int findNeighbors( Mat& points, Mat& neighbors );
+    virtual int checkFindBoxed();
+    virtual void releaseModel();
+    KDTree* tr;
+};
+
+
+void CV_KDTreeTest_CPP::createModel( const Mat& data )
+{
+    tr = new KDTree( data, false );
+}
+
+int CV_KDTreeTest_CPP::checkGetPoins( const Mat& data )
+{
+    Mat res1( data.size(), data.type() ),
+        res2( data.size(), data.type() ),
+        res3( data.size(), data.type() );
+    Mat idxs( 1, data.rows, CV_32SC1 );
+    for( int pi = 0; pi < data.rows; pi++ )
+    {
+        idxs.at<int>(0, pi) = pi;
+        // 1st way
+        const float* point = tr->getPoint(pi);
+        for( int di = 0; di < data.cols; di++ )
+            res1.at<float>(pi, di) = point[di];
+    }
+    // 2nd way
+    tr->getPoints( idxs.ptr<int>(0), data.rows, res2 );
+
+    // 3d way
+    tr->getPoints( idxs, res3 );
+
+    if( norm( res1, data, NORM_L1) != 0 ||
+        norm( res2, data, NORM_L1) != 0 ||
+        norm( res3, data, NORM_L1) != 0)
+        return cvtest::TS::FAIL_BAD_ACCURACY;
+    return cvtest::TS::OK;
+}
+
+int CV_KDTreeTest_CPP::checkFindBoxed()
+{
+    vector<float> min( dims, minValue), max(dims, maxValue);
+    vector<int> indices;
+    tr->findOrthoRange( &min[0], &max[0], &indices );
+    // TODO check indices
+    if( (int)indices.size() != featuresCount)
+        return cvtest::TS::FAIL_BAD_ACCURACY;
+    return cvtest::TS::OK;
+}
+
+int CV_KDTreeTest_CPP::findNeighbors( Mat& points, Mat& neighbors )
+{
+    const int emax = 20;
+    Mat neighbors2( neighbors.size(), CV_32SC1 );
+    int j;
+    vector<float> min(points.cols, minValue);
+    vector<float> max(points.cols, maxValue);
+    for( int pi = 0; pi < points.rows; pi++ )
+    {
+        // 1st way
+        tr->findNearest( points.ptr<float>(pi), neighbors.cols, emax, neighbors.ptr<int>(pi) );
+
+        // 2nd way
+        vector<int> neighborsIdx2( neighbors2.cols, 0 );
+        tr->findNearest( points.ptr<float>(pi), neighbors2.cols, emax, &neighborsIdx2 );
+        vector<int>::const_iterator it2 = neighborsIdx2.begin();
+        for( j = 0; it2 != neighborsIdx2.end(); ++it2, j++ )
+            neighbors2.at<int>(pi,j) = *it2;
+    }
+
+    // compare results
+    if( norm( neighbors, neighbors2, NORM_L1 ) != 0 )
+        return cvtest::TS::FAIL_BAD_ACCURACY;
+
+    return cvtest::TS::OK;
+}
+
+void CV_KDTreeTest_CPP::releaseModel()
+{
+    delete tr;
+}
+
+//--------------------------------------------------------------------------------
+class CV_FlannTest : public NearestNeighborTest
+{
+public:
+    CV_FlannTest() {}
+protected:
+    void createIndex( const Mat& data, const IndexParams& params );
+    int knnSearch( Mat& points, Mat& neighbors );
+    int radiusSearch( Mat& points, Mat& neighbors );
+    virtual void releaseModel();
+    Index* index;
+};
+
+void CV_FlannTest::createIndex( const Mat& data, const IndexParams& params )
+{
+    index = new Index( data, params );
+}
+
+int CV_FlannTest::knnSearch( Mat& points, Mat& neighbors )
+{
+    Mat dist( points.rows, neighbors.cols, CV_32FC1);
+    int knn = 1, j;
+
+    // 1st way
+    index->knnSearch( points, neighbors, dist, knn, SearchParams() );
+
+    // 2nd way
+    Mat neighbors1( neighbors.size(), CV_32SC1 );
+    for( int i = 0; i < points.rows; i++ )
+    {
+        float* fltPtr = points.ptr<float>(i);
+        vector<float> query( fltPtr, fltPtr + points.cols );
+        vector<int> indices( neighbors1.cols, 0 );
+        vector<float> dists( dist.cols, 0 );
+        index->knnSearch( query, indices, dists, knn, SearchParams() );
+        vector<int>::const_iterator it = indices.begin();
+        for( j = 0; it != indices.end(); ++it, j++ )
+            neighbors1.at<int>(i,j) = *it;
+    }
+
+    // compare results
+    if( norm( neighbors, neighbors1, NORM_L1 ) != 0 )
+        return cvtest::TS::FAIL_BAD_ACCURACY;
+
+    return cvtest::TS::OK;
+}
+
+int CV_FlannTest::radiusSearch( Mat& points, Mat& neighbors )
+{
+    Mat dist( 1, neighbors.cols, CV_32FC1);
+    Mat neighbors1( neighbors.size(), CV_32SC1 );
+    float radius = 10.0f;
+    int j;
+
+    // radiusSearch can only search one feature at a time for range search
+    for( int i = 0; i < points.rows; i++ )
+    {
+        // 1st way
+        Mat p( 1, points.cols, CV_32FC1, points.ptr<float>(i) ),
+            n( 1, neighbors.cols, CV_32SC1, neighbors.ptr<int>(i) );
+        index->radiusSearch( p, n, dist, radius, SearchParams() );
+
+        // 2nd way
+        float* fltPtr = points.ptr<float>(i);
+        vector<float> query( fltPtr, fltPtr + points.cols );
+        vector<int> indices( neighbors1.cols, 0 );
+        vector<float> dists( dist.cols, 0 );
+        index->radiusSearch( query, indices, dists, radius, SearchParams() );
+        vector<int>::const_iterator it = indices.begin();
+        for( j = 0; it != indices.end(); ++it, j++ )
+            neighbors1.at<int>(i,j) = *it;
+    }
+    // compare results
+    if( norm( neighbors, neighbors1, NORM_L1 ) != 0 )
+        return cvtest::TS::FAIL_BAD_ACCURACY;
+
+    return cvtest::TS::OK;
+}
+
+void CV_FlannTest::releaseModel()
+{
+    delete index;
+}
+
+//---------------------------------------
+class CV_FlannLinearIndexTest : public CV_FlannTest
+{
+public:
+    CV_FlannLinearIndexTest() {}
+protected:
+    virtual void createModel( const Mat& data ) { createIndex( data, LinearIndexParams() ); }
+    virtual int findNeighbors( Mat& points, Mat& neighbors ) { return knnSearch( points, neighbors ); }
+};
+
+//---------------------------------------
+class CV_FlannKMeansIndexTest : public CV_FlannTest
+{
+public:
+    CV_FlannKMeansIndexTest() {}
+protected:
+    virtual void createModel( const Mat& data ) { createIndex( data, KMeansIndexParams() ); }
+    virtual int findNeighbors( Mat& points, Mat& neighbors ) { return radiusSearch( points, neighbors ); }
+};
+
+//---------------------------------------
+class CV_FlannKDTreeIndexTest : public CV_FlannTest
+{
+public:
+    CV_FlannKDTreeIndexTest() {}
+protected:
+    virtual void createModel( const Mat& data ) { createIndex( data, KDTreeIndexParams() ); }
+    virtual int findNeighbors( Mat& points, Mat& neighbors ) { return radiusSearch( points, neighbors ); }
+};
+
+//----------------------------------------
+class CV_FlannCompositeIndexTest : public CV_FlannTest
+{
+public:
+    CV_FlannCompositeIndexTest() {}
+protected:
+    virtual void createModel( const Mat& data ) { createIndex( data, CompositeIndexParams() ); }
+    virtual int findNeighbors( Mat& points, Mat& neighbors ) { return knnSearch( points, neighbors ); }
+};
+
+//----------------------------------------
+class CV_FlannAutotunedIndexTest : public CV_FlannTest
+{
+public:
+    CV_FlannAutotunedIndexTest() {}
+protected:
+    virtual void createModel( const Mat& data ) { createIndex( data, AutotunedIndexParams() ); }
+    virtual int findNeighbors( Mat& points, Mat& neighbors ) { return knnSearch( points, neighbors ); }
+};
+//----------------------------------------
+class CV_FlannSavedIndexTest : public CV_FlannTest
+{
+public:
+    CV_FlannSavedIndexTest() {}
+protected:
+    virtual void createModel( const Mat& data );
+    virtual int findNeighbors( Mat& points, Mat& neighbors ) { return knnSearch( points, neighbors ); }
+};
+
+void CV_FlannSavedIndexTest::createModel(const cv::Mat &data)
+{
+    switch ( cvtest::randInt(ts->get_rng()) % 2 )
+    {
+        //case 0: createIndex( data, LinearIndexParams() ); break; // nothing to save for linear search
+        case 0: createIndex( data, KMeansIndexParams() ); break;
+        case 1: createIndex( data, KDTreeIndexParams() ); break;
+        //case 2: createIndex( data, CompositeIndexParams() ); break; // nothing to save for linear search
+        //case 2: createIndex( data, AutotunedIndexParams() ); break; // possible linear index !
+        default: assert(0);
+    }
+    char filename[50];
+    tmpnam( filename );
+    if(filename[0] == '\\') filename[0] = '_';
+    index->save( filename );
+    
+    createIndex( data, SavedIndexParams(filename));
+    remove( filename );
+}
+
+TEST(Features2d_LSH, regression) { CV_LSHTest test; test.safe_run(); }
+TEST(Features2d_SpillTree, regression) { CV_SpillTreeTest_C test; test.safe_run(); }
+TEST(Features2d_KDTree_C, regression) { CV_KDTreeTest_C test; test.safe_run(); }
+TEST(Features2d_KDTree_CPP, regression) { CV_KDTreeTest_CPP test; test.safe_run(); }
+TEST(Features2d_FLANN_Linear, regression) { CV_FlannLinearIndexTest test; test.safe_run(); }
+TEST(Features2d_FLANN_KMeans, regression) { CV_FlannKMeansIndexTest test; test.safe_run(); }
+TEST(Features2d_FLANN_KDTree, regression) { CV_FlannKDTreeIndexTest test; test.safe_run(); }
+TEST(Features2d_FLANN_Composite, regression) { CV_FlannCompositeIndexTest test; test.safe_run(); }
+TEST(Features2d_FLANN_Auto, regression) { CV_FlannAutotunedIndexTest test; test.safe_run(); }
+TEST(Features2d_FLANN_Saved, regression) { CV_FlannSavedIndexTest test; test.safe_run(); }

modules/features2d/test/test_precomp.cpp

@@ -0,0 +1 @@
+#include "test_precomp.hpp"

modules/features2d/test/test_precomp.hpp

@@ -0,0 +1,11 @@
+#ifndef __OPENCV_TEST_PRECOMP_HPP__
+#define __OPENCV_TEST_PRECOMP_HPP__
+
+#include "opencv2/ts/ts.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include <iostream>
+
+#endif