Modified java wrapping mechanism

modules/features2d/misc/java/filelist

@@ -0,0 +1 @@
+misc/java/src/cpp/features2d_manual.hpp

modules/features2d/misc/java/src/cpp/features2d_converters.cpp

@@ -0,0 +1,112 @@
+#define LOG_TAG "org.opencv.utils.Converters"
+#include "common.h"
+#include "features2d_converters.hpp"
+
+using namespace cv;
+
+#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; }
+
+
+//vector_KeyPoint
+void Mat_to_vector_KeyPoint(Mat& mat, std::vector<KeyPoint>& v_kp)
+{
+    v_kp.clear();
+    CHECK_MAT(mat.type()==CV_32FC(7) && mat.cols==1);
+    for(int i=0; i<mat.rows; i++)
+    {
+        Vec<float, 7> v = mat.at< Vec<float, 7> >(i, 0);
+        KeyPoint kp(v[0], v[1], v[2], v[3], v[4], (int)v[5], (int)v[6]);
+        v_kp.push_back(kp);
+    }
+    return;
+}
+
+
+void vector_KeyPoint_to_Mat(std::vector<KeyPoint>& v_kp, Mat& mat)
+{
+    int count = (int)v_kp.size();
+    mat.create(count, 1, CV_32FC(7));
+    for(int i=0; i<count; i++)
+    {
+        KeyPoint kp = v_kp[i];
+        mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, (float)kp.octave, (float)kp.class_id);
+    }
+}
+
+//vector_DMatch
+void Mat_to_vector_DMatch(Mat& mat, std::vector<DMatch>& v_dm)
+{
+    v_dm.clear();
+    CHECK_MAT(mat.type()==CV_32FC4 && mat.cols==1);
+    for(int i=0; i<mat.rows; i++)
+    {
+        Vec<float, 4> v = mat.at< Vec<float, 4> >(i, 0);
+        DMatch dm((int)v[0], (int)v[1], (int)v[2], v[3]);
+        v_dm.push_back(dm);
+    }
+    return;
+}
+
+
+void vector_DMatch_to_Mat(std::vector<DMatch>& v_dm, Mat& mat)
+{
+    int count = (int)v_dm.size();
+    mat.create(count, 1, CV_32FC4);
+    for(int i=0; i<count; i++)
+    {
+        DMatch dm = v_dm[i];
+        mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>((float)dm.queryIdx, (float)dm.trainIdx, (float)dm.imgIdx, dm.distance);
+    }
+}
+
+void Mat_to_vector_vector_KeyPoint(Mat& mat, std::vector< std::vector< KeyPoint > >& vv_kp)
+{
+    std::vector<Mat> vm;
+    vm.reserve( mat.rows );
+    Mat_to_vector_Mat(mat, vm);
+    for(size_t i=0; i<vm.size(); i++)
+    {
+        std::vector<KeyPoint> vkp;
+        Mat_to_vector_KeyPoint(vm[i], vkp);
+        vv_kp.push_back(vkp);
+    }
+}
+
+void vector_vector_KeyPoint_to_Mat(std::vector< std::vector< KeyPoint > >& vv_kp, Mat& mat)
+{
+    std::vector<Mat> vm;
+    vm.reserve( vv_kp.size() );
+    for(size_t i=0; i<vv_kp.size(); i++)
+    {
+        Mat m;
+        vector_KeyPoint_to_Mat(vv_kp[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}
+
+void Mat_to_vector_vector_DMatch(Mat& mat, std::vector< std::vector< DMatch > >& vv_dm)
+{
+    std::vector<Mat> vm;
+    vm.reserve( mat.rows );
+    Mat_to_vector_Mat(mat, vm);
+    for(size_t i=0; i<vm.size(); i++)
+    {
+        std::vector<DMatch> vdm;
+        Mat_to_vector_DMatch(vm[i], vdm);
+        vv_dm.push_back(vdm);
+    }
+}
+
+void vector_vector_DMatch_to_Mat(std::vector< std::vector< DMatch > >& vv_dm, Mat& mat)
+{
+    std::vector<Mat> vm;
+    vm.reserve( vv_dm.size() );
+    for(size_t i=0; i<vv_dm.size(); i++)
+    {
+        Mat m;
+        vector_DMatch_to_Mat(vv_dm[i], m);
+        vm.push_back(m);
+    }
+    vector_Mat_to_Mat(vm, mat);
+}

modules/features2d/misc/java/src/cpp/features2d_converters.hpp

@@ -0,0 +1,22 @@
+#ifndef __FEATURES2D_CONVERTERS_HPP__
+#define __FEATURES2D_CONVERTERS_HPP__
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/core.hpp"
+
+#include "features2d_manual.hpp"
+
+void Mat_to_vector_KeyPoint(cv::Mat& mat, std::vector<cv::KeyPoint>& v_kp);
+void vector_KeyPoint_to_Mat(std::vector<cv::KeyPoint>& v_kp, cv::Mat& mat);
+
+void Mat_to_vector_DMatch(cv::Mat& mat, std::vector<cv::DMatch>& v_dm);
+void vector_DMatch_to_Mat(std::vector<cv::DMatch>& v_dm, cv::Mat& mat);
+
+void Mat_to_vector_vector_KeyPoint(cv::Mat& mat, std::vector< std::vector< cv::KeyPoint > >& vv_kp);
+void vector_vector_KeyPoint_to_Mat(std::vector< std::vector< cv::KeyPoint > >& vv_kp, cv::Mat& mat);
+
+void Mat_to_vector_vector_DMatch(cv::Mat& mat, std::vector< std::vector< cv::DMatch > >& vv_dm);
+void vector_vector_DMatch_to_Mat(std::vector< std::vector< cv::DMatch > >& vv_dm, cv::Mat& mat);
+
+
+#endif

modules/features2d/misc/java/src/cpp/features2d_manual.hpp

@@ -0,0 +1,434 @@
+#ifndef __OPENCV_FEATURES_2D_MANUAL_HPP__
+#define __OPENCV_FEATURES_2D_MANUAL_HPP__
+
+#include "opencv2/opencv_modules.hpp"
+
+#ifdef HAVE_OPENCV_FEATURES2D
+#include "opencv2/features2d.hpp"
+#include "features2d_converters.hpp"
+
+#undef SIMPLEBLOB // to solve conflict with wincrypt.h on windows
+
+namespace cv
+{
+
+class CV_EXPORTS_AS(FeatureDetector) javaFeatureDetector
+{
+public:
+    CV_WRAP void detect( const Mat& image, CV_OUT std::vector<KeyPoint>& keypoints, const Mat& mask=Mat() ) const
+    { return wrapped->detect(image, keypoints, mask); }
+
+    CV_WRAP void detect( const std::vector<Mat>& images, CV_OUT std::vector<std::vector<KeyPoint> >& keypoints, const std::vector<Mat>& masks=std::vector<Mat>() ) const
+    { return wrapped->detect(images, keypoints, masks); }
+
+    CV_WRAP bool empty() const
+    { return wrapped->empty(); }
+
+    enum
+    {
+        FAST          = 1,
+        STAR          = 2,
+        SIFT          = 3,
+        SURF          = 4,
+        ORB           = 5,
+        MSER          = 6,
+        GFTT          = 7,
+        HARRIS        = 8,
+        SIMPLEBLOB    = 9,
+        DENSE         = 10,
+        BRISK         = 11,
+        AKAZE         = 12,
+
+
+        GRIDDETECTOR = 1000,
+
+        GRID_FAST          = GRIDDETECTOR + FAST,
+        GRID_STAR          = GRIDDETECTOR + STAR,
+        GRID_SIFT          = GRIDDETECTOR + SIFT,
+        GRID_SURF          = GRIDDETECTOR + SURF,
+        GRID_ORB           = GRIDDETECTOR + ORB,
+        GRID_MSER          = GRIDDETECTOR + MSER,
+        GRID_GFTT          = GRIDDETECTOR + GFTT,
+        GRID_HARRIS        = GRIDDETECTOR + HARRIS,
+        GRID_SIMPLEBLOB    = GRIDDETECTOR + SIMPLEBLOB,
+        GRID_DENSE         = GRIDDETECTOR + DENSE,
+        GRID_BRISK         = GRIDDETECTOR + BRISK,
+        GRID_AKAZE         = GRIDDETECTOR + AKAZE,
+
+
+        PYRAMIDDETECTOR = 2000,
+
+        PYRAMID_FAST       = PYRAMIDDETECTOR + FAST,
+        PYRAMID_STAR       = PYRAMIDDETECTOR + STAR,
+        PYRAMID_SIFT       = PYRAMIDDETECTOR + SIFT,
+        PYRAMID_SURF       = PYRAMIDDETECTOR + SURF,
+        PYRAMID_ORB        = PYRAMIDDETECTOR + ORB,
+        PYRAMID_MSER       = PYRAMIDDETECTOR + MSER,
+        PYRAMID_GFTT       = PYRAMIDDETECTOR + GFTT,
+        PYRAMID_HARRIS     = PYRAMIDDETECTOR + HARRIS,
+        PYRAMID_SIMPLEBLOB = PYRAMIDDETECTOR + SIMPLEBLOB,
+        PYRAMID_DENSE      = PYRAMIDDETECTOR + DENSE,
+        PYRAMID_BRISK      = PYRAMIDDETECTOR + BRISK,
+        PYRAMID_AKAZE      = PYRAMIDDETECTOR + AKAZE,
+
+        DYNAMICDETECTOR = 3000,
+
+        DYNAMIC_FAST       = DYNAMICDETECTOR + FAST,
+        DYNAMIC_STAR       = DYNAMICDETECTOR + STAR,
+        DYNAMIC_SIFT       = DYNAMICDETECTOR + SIFT,
+        DYNAMIC_SURF       = DYNAMICDETECTOR + SURF,
+        DYNAMIC_ORB        = DYNAMICDETECTOR + ORB,
+        DYNAMIC_MSER       = DYNAMICDETECTOR + MSER,
+        DYNAMIC_GFTT       = DYNAMICDETECTOR + GFTT,
+        DYNAMIC_HARRIS     = DYNAMICDETECTOR + HARRIS,
+        DYNAMIC_SIMPLEBLOB = DYNAMICDETECTOR + SIMPLEBLOB,
+        DYNAMIC_DENSE      = DYNAMICDETECTOR + DENSE,
+        DYNAMIC_BRISK      = DYNAMICDETECTOR + BRISK,
+        DYNAMIC_AKAZE      = DYNAMICDETECTOR + AKAZE
+    };
+
+    //supported: FAST STAR SIFT SURF ORB MSER GFTT HARRIS BRISK AKAZE Grid(XXXX) Pyramid(XXXX) Dynamic(XXXX)
+    //not supported: SimpleBlob, Dense
+    CV_WRAP static javaFeatureDetector* create( int detectorType )
+    {
+        //String name;
+        if (detectorType > DYNAMICDETECTOR)
+        {
+            //name = "Dynamic";
+            detectorType -= DYNAMICDETECTOR;
+        }
+        if (detectorType > PYRAMIDDETECTOR)
+        {
+            //name = "Pyramid";
+            detectorType -= PYRAMIDDETECTOR;
+        }
+        if (detectorType > GRIDDETECTOR)
+        {
+            //name = "Grid";
+            detectorType -= GRIDDETECTOR;
+        }
+
+        Ptr<FeatureDetector> fd;
+        switch(detectorType)
+        {
+        case FAST:
+            fd = FastFeatureDetector::create();
+            break;
+        //case STAR:
+        //    fd = xfeatures2d::StarDetector::create();
+        //    break;
+        //case SIFT:
+        //    name = name + "SIFT";
+        //    break;
+        //case SURF:
+        //    name = name + "SURF";
+        //    break;
+        case ORB:
+            fd = ORB::create();
+            break;
+        case MSER:
+            fd = MSER::create();
+            break;
+        case GFTT:
+            fd = GFTTDetector::create();
+            break;
+        case HARRIS:
+            {
+            Ptr<GFTTDetector> gftt = GFTTDetector::create();
+            gftt->setHarrisDetector(true);
+            fd = gftt;
+            }
+            break;
+        case SIMPLEBLOB:
+            fd = SimpleBlobDetector::create();
+            break;
+        //case DENSE:
+        //    name = name + "Dense";
+        //    break;
+        case BRISK:
+            fd = BRISK::create();
+            break;
+        case AKAZE:
+            fd = AKAZE::create();
+            break;
+        default:
+            CV_Error( Error::StsBadArg, "Specified feature detector type is not supported." );
+            break;
+        }
+
+        return new javaFeatureDetector(fd);
+    }
+
+    CV_WRAP void write( const String& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        wrapped->write(fs);
+    }
+
+    CV_WRAP void read( const String& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        wrapped->read(fs.root());
+    }
+
+private:
+    javaFeatureDetector(Ptr<FeatureDetector> _wrapped) : wrapped(_wrapped)
+    {}
+
+    Ptr<FeatureDetector> wrapped;
+};
+
+class CV_EXPORTS_AS(DescriptorMatcher) javaDescriptorMatcher
+{
+public:
+    CV_WRAP bool isMaskSupported() const
+    { return wrapped->isMaskSupported(); }
+
+    CV_WRAP void add( const std::vector<Mat>& descriptors )
+    { return wrapped->add(descriptors); }
+
+    CV_WRAP const std::vector<Mat>& getTrainDescriptors() const
+    { return wrapped->getTrainDescriptors(); }
+
+    CV_WRAP void clear()
+    { return wrapped->clear(); }
+
+    CV_WRAP bool empty() const
+    { return wrapped->empty(); }
+
+    CV_WRAP void train()
+    { return wrapped->train(); }
+
+    CV_WRAP void match( const Mat& queryDescriptors, const Mat& trainDescriptors,
+                CV_OUT std::vector<DMatch>& matches, const Mat& mask=Mat() ) const
+    { return wrapped->match(queryDescriptors, trainDescriptors, matches, mask); }
+
+    CV_WRAP void knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors,
+                   CV_OUT std::vector<std::vector<DMatch> >& matches, int k,
+                   const Mat& mask=Mat(), bool compactResult=false ) const
+    { return wrapped->knnMatch(queryDescriptors, trainDescriptors, matches, k, mask, compactResult); }
+
+    CV_WRAP void radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors,
+                      CV_OUT std::vector<std::vector<DMatch> >& matches, float maxDistance,
+                      const Mat& mask=Mat(), bool compactResult=false ) const
+    { return wrapped->radiusMatch(queryDescriptors, trainDescriptors, matches, maxDistance, mask, compactResult); }
+
+    CV_WRAP void match( const Mat& queryDescriptors, CV_OUT std::vector<DMatch>& matches,
+                const std::vector<Mat>& masks=std::vector<Mat>() )
+    { return wrapped->match(queryDescriptors, matches, masks); }
+
+    CV_WRAP void knnMatch( const Mat& queryDescriptors, CV_OUT std::vector<std::vector<DMatch> >& matches, int k,
+           const std::vector<Mat>& masks=std::vector<Mat>(), bool compactResult=false )
+    { return wrapped->knnMatch(queryDescriptors, matches, k, masks, compactResult); }
+
+    CV_WRAP void radiusMatch( const Mat& queryDescriptors, CV_OUT std::vector<std::vector<DMatch> >& matches, float maxDistance,
+                   const std::vector<Mat>& masks=std::vector<Mat>(), bool compactResult=false )
+    { return wrapped->radiusMatch(queryDescriptors, matches, maxDistance, masks, compactResult); }
+
+    enum
+    {
+        FLANNBASED            = 1,
+        BRUTEFORCE            = 2,
+        BRUTEFORCE_L1         = 3,
+        BRUTEFORCE_HAMMING    = 4,
+        BRUTEFORCE_HAMMINGLUT = 5,
+        BRUTEFORCE_SL2        = 6
+    };
+
+    CV_WRAP_AS(clone) javaDescriptorMatcher* jclone( bool emptyTrainData=false ) const
+    {
+        return new javaDescriptorMatcher(wrapped->clone(emptyTrainData));
+    }
+
+    //supported: FlannBased, BruteForce, BruteForce-L1, BruteForce-Hamming, BruteForce-HammingLUT
+    CV_WRAP static javaDescriptorMatcher* create( int matcherType )
+    {
+        String name;
+
+        switch(matcherType)
+        {
+        case FLANNBASED:
+            name = "FlannBased";
+            break;
+        case BRUTEFORCE:
+            name = "BruteForce";
+            break;
+        case BRUTEFORCE_L1:
+            name = "BruteForce-L1";
+            break;
+        case BRUTEFORCE_HAMMING:
+            name = "BruteForce-Hamming";
+            break;
+        case BRUTEFORCE_HAMMINGLUT:
+            name = "BruteForce-HammingLUT";
+            break;
+        case BRUTEFORCE_SL2:
+            name = "BruteForce-SL2";
+            break;
+        default:
+            CV_Error( Error::StsBadArg, "Specified descriptor matcher type is not supported." );
+            break;
+        }
+
+        return new javaDescriptorMatcher(DescriptorMatcher::create(name));
+    }
+
+    CV_WRAP void write( const String& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        wrapped->write(fs);
+    }
+
+    CV_WRAP void read( const String& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        wrapped->read(fs.root());
+    }
+
+private:
+    javaDescriptorMatcher(Ptr<DescriptorMatcher> _wrapped) : wrapped(_wrapped)
+    {}
+
+    Ptr<DescriptorMatcher> wrapped;
+};
+
+class CV_EXPORTS_AS(DescriptorExtractor) javaDescriptorExtractor
+{
+public:
+    CV_WRAP void compute( const Mat& image, CV_IN_OUT std::vector<KeyPoint>& keypoints, Mat& descriptors ) const
+    { return wrapped->compute(image, keypoints, descriptors); }
+
+    CV_WRAP void compute( const std::vector<Mat>& images, CV_IN_OUT std::vector<std::vector<KeyPoint> >& keypoints, CV_OUT std::vector<Mat>& descriptors ) const
+    { return wrapped->compute(images, keypoints, descriptors); }
+
+    CV_WRAP int descriptorSize() const
+    { return wrapped->descriptorSize(); }
+
+    CV_WRAP int descriptorType() const
+    { return wrapped->descriptorType(); }
+
+    CV_WRAP bool empty() const
+    { return wrapped->empty(); }
+
+    enum
+    {
+        SIFT  = 1,
+        SURF  = 2,
+        ORB   = 3,
+        BRIEF = 4,
+        BRISK = 5,
+        FREAK = 6,
+        AKAZE = 7,
+
+
+        OPPONENTEXTRACTOR = 1000,
+
+
+
+        OPPONENT_SIFT  = OPPONENTEXTRACTOR + SIFT,
+        OPPONENT_SURF  = OPPONENTEXTRACTOR + SURF,
+        OPPONENT_ORB   = OPPONENTEXTRACTOR + ORB,
+        OPPONENT_BRIEF = OPPONENTEXTRACTOR + BRIEF,
+        OPPONENT_BRISK = OPPONENTEXTRACTOR + BRISK,
+        OPPONENT_FREAK = OPPONENTEXTRACTOR + FREAK,
+        OPPONENT_AKAZE = OPPONENTEXTRACTOR + AKAZE
+    };
+
+    //supported SIFT, SURF, ORB, BRIEF, BRISK, FREAK, AKAZE, Opponent(XXXX)
+    //not supported: Calonder
+    CV_WRAP static javaDescriptorExtractor* create( int extractorType )
+    {
+        //String name;
+
+        if (extractorType > OPPONENTEXTRACTOR)
+        {
+            //name = "Opponent";
+            extractorType -= OPPONENTEXTRACTOR;
+        }
+
+        Ptr<DescriptorExtractor> de;
+        switch(extractorType)
+        {
+        //case SIFT:
+        //    name = name + "SIFT";
+        //    break;
+        //case SURF:
+        //    name = name + "SURF";
+        //    break;
+        case ORB:
+            de = ORB::create();
+            break;
+        //case BRIEF:
+        //    name = name + "BRIEF";
+        //    break;
+        case BRISK:
+            de = BRISK::create();
+            break;
+        //case FREAK:
+        //    name = name + "FREAK";
+        //    break;
+        case AKAZE:
+            de = AKAZE::create();
+            break;
+        default:
+            CV_Error( Error::StsBadArg, "Specified descriptor extractor type is not supported." );
+            break;
+        }
+
+        return new javaDescriptorExtractor(de);
+    }
+
+    CV_WRAP void write( const String& fileName ) const
+    {
+        FileStorage fs(fileName, FileStorage::WRITE);
+        wrapped->write(fs);
+    }
+
+    CV_WRAP void read( const String& fileName )
+    {
+        FileStorage fs(fileName, FileStorage::READ);
+        wrapped->read(fs.root());
+    }
+
+private:
+    javaDescriptorExtractor(Ptr<DescriptorExtractor> _wrapped) : wrapped(_wrapped)
+    {}
+
+    Ptr<DescriptorExtractor> wrapped;
+};
+
+#if 0
+//DO NOT REMOVE! The block is required for sources parser
+enum
+{
+          DRAW_OVER_OUTIMG = 1, // Output image matrix will not be created (Mat::create).
+                                // Matches will be drawn on existing content of output image.
+          NOT_DRAW_SINGLE_POINTS = 2, // Single keypoints will not be drawn.
+          DRAW_RICH_KEYPOINTS = 4 // For each keypoint the circle around keypoint with keypoint size and
+                                  // orientation will be drawn.
+};
+
+// Draw keypoints.
+CV_EXPORTS_W void drawKeypoints( const Mat& image, const std::vector<KeyPoint>& keypoints, Mat& outImage,
+                               const Scalar& color=Scalar::all(-1), int flags=0 );
+
+// Draws matches of keypints from two images on output image.
+CV_EXPORTS_W void drawMatches( const Mat& img1, const std::vector<KeyPoint>& keypoints1,
+                             const Mat& img2, const std::vector<KeyPoint>& keypoints2,
+                             const std::vector<DMatch>& matches1to2, Mat& outImg,
+                             const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
+                             const std::vector<char>& matchesMask=std::vector<char>(), int flags=0 );
+
+CV_EXPORTS_AS(drawMatches2) void drawMatches( const Mat& img1, const std::vector<KeyPoint>& keypoints1,
+                             const Mat& img2, const std::vector<KeyPoint>& keypoints2,
+                             const std::vector<std::vector<DMatch> >& matches1to2, Mat& outImg,
+                             const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1),
+                             const std::vector<std::vector<char> >& matchesMask=std::vector<std::vector<char> >(), int flags=0);
+
+#endif
+
+} //cv
+
+#endif // HAVE_OPENCV_FEATURES2D
+
+#endif // __OPENCV_FEATURES_2D_MANUAL_HPP__

modules/features2d/misc/java/test/BRIEFDescriptorExtractorTest.java

@@ -0,0 +1,102 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class BRIEFDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    int matSize;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
+        matSize = 100;
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 32, CvType.CV_8UC1) {
+            {
+                put(0, 0, 96, 0, 76, 24, 47, 182, 68, 137,
+                          149, 195, 67, 16, 187, 224, 74, 8,
+                          82, 169, 87, 70, 44, 4, 192, 56,
+                          13, 128, 44, 106, 146, 72, 194, 245);
+            }
+        };
+
+        assertMatEqual(truth, descriptors);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(32, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_8U, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\ndescriptorSize: 64\n");
+
+        extractor.read(filename);
+
+        assertEquals(64, extractor.descriptorSize());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<descriptorSize>32</descriptorSize>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\ndescriptorSize: 32\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/BruteForceDescriptorMatcherTest.java

@@ -0,0 +1,295 @@
+package org.opencv.test.features2d;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Imgproc.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 0.6211397f),
+                new DMatch(1, 1, 0, 0.9177120f),
+                new DMatch(2, 1, 0, 0.3112163f),
+                new DMatch(3, 1, 0, 0.2925074f),
+                new DMatch(4, 1, 0, 0.9309178f)
+                };
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        final int k = 3;
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        List<MatOfDMatch> matches = new ArrayList<MatOfDMatch>();
+        matcher.knnMatch(query, train, matches, k);
+        /*
+        Log.d("knnMatch", "train = " + train);
+        Log.d("knnMatch", "query = " + query);
+
+        matcher.add(train);
+        matcher.knnMatch(query, matches, k);
+        */
+        assertEquals(query.rows(), matches.size());
+        for(int i = 0; i<matches.size(); i++)
+        {
+            MatOfDMatch vdm = matches.get(i);
+            //Log.d("knn", "vdm["+i+"]="+vdm.dump());
+            assertTrue(Math.min(k, train.rows()) >= vdm.total());
+            for(DMatch dm : vdm.toArray())
+            {
+                assertEquals(dm.queryIdx, i);
+            }
+        }
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+
+        // OpenCVTestRunner.Log("matches found: " + matches.size());
+        // for (DMatch m : matches)
+        // OpenCVTestRunner.Log(m.toString());
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/BruteForceHammingDescriptorMatcherTest.java

@@ -0,0 +1,263 @@
+package org.opencv.test.features2d;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class BruteForceHammingDescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(4, 4, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        return getTestDescriptors(getQueryImg());
+    }
+
+    private Mat getQueryImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(img, new Point(40, matSize - 40), new Point(matSize - 50, 50), new Scalar(0), 8);
+        return img;
+    }
+
+    private Mat getTestDescriptors(Mat img) {
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.FAST);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainDescriptors() {
+        return getTestDescriptors(getTrainImg());
+    }
+
+    private Mat getTrainImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(img, new Point(40, 40), new Point(matSize - 40, matSize - 40), new Scalar(0), 8);
+        return img;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMING);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 51),
+                new DMatch(1, 2, 0, 42),
+                new DMatch(2, 1, 0, 40),
+                new DMatch(3, 3, 0, 53) };
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches.toList(), EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches.toList(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        ArrayList<MatOfDMatch> matches = new ArrayList<MatOfDMatch>();
+
+        matcher.radiusMatch(query, train, matches, 50.f);
+
+        assertEquals(matches.size(), 4);
+        assertTrue(matches.get(0).empty());
+        assertMatEqual(matches.get(1), new MatOfDMatch(truth[1]), EPS);
+        assertMatEqual(matches.get(2), new MatOfDMatch(truth[2]), EPS);
+        assertTrue(matches.get(3).empty());
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/BruteForceHammingLUTDescriptorMatcherTest.java

@@ -0,0 +1,258 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class BruteForceHammingLUTDescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(4, 4, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        return getTestDescriptors(getQueryImg());
+    }
+
+    private Mat getQueryImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(img, new Point(40, matSize - 40), new Point(matSize - 50, 50), new Scalar(0), 8);
+        return img;
+    }
+
+    private Mat getTestDescriptors(Mat img) {
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.FAST);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.BRIEF);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainDescriptors() {
+        return getTestDescriptors(getTrainImg());
+    }
+
+    private Mat getTrainImg() {
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(img, new Point(40, 40), new Point(matSize - 40, matSize - 40), new Scalar(0), 8);
+        return img;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_HAMMINGLUT);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 51),
+                new DMatch(1, 2, 0, 42),
+                new DMatch(2, 1, 0, 40),
+                new DMatch(3, 3, 0, 53) };
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches);
+
+        /*
+        OpenCVTestRunner.Log("matches found: " + matches.size());
+        for (DMatch m : matches.toArray())
+            OpenCVTestRunner.Log(m.toString());
+        */
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/BruteForceL1DescriptorMatcherTest.java

@@ -0,0 +1,269 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class BruteForceL1DescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        //writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        writeFile(filename, "%YAML:1.0\nname: \"Feature2D.SURF\"\nextended: 1\nhessianThreshold: 8000.\nnOctaveLayers: 2\nnOctaves: 3\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Imgproc.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_L1);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 3.0975165f),
+                new DMatch(1, 1, 0, 3.5680308f),
+                new DMatch(2, 1, 0, 1.3722466f),
+                new DMatch(3, 1, 0, 1.3041023f),
+                new DMatch(4, 1, 0, 3.5970376f)
+                };
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/BruteForceSL2DescriptorMatcherTest.java

@@ -0,0 +1,281 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class BruteForceSL2DescriptorMatcherTest extends OpenCVTestCase {
+
+    DescriptorMatcher matcher;
+    int matSize;
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    /*
+    private float sqr(float val){
+        return val * val;
+    }
+    */
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Imgproc.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_SL2);
+        matSize = 100;
+
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 0.3858146f),
+                new DMatch(1, 1, 0, 0.8421953f),
+                new DMatch(2, 1, 0, 0.0968556f),
+                new DMatch(3, 1, 0, 0.0855606f),
+                new DMatch(4, 1, 0, 0.8666080f)
+                };
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        DescriptorMatcher cloned = matcher.clone();
+
+        assertNotNull(cloned);
+
+        List<Mat> descriptors = cloned.getTrainDescriptors();
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertTrue(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches);
+        OpenCVTestRunner.Log(matches);
+        OpenCVTestRunner.Log(matches);
+        OpenCVTestRunner.Log(matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+
+        // OpenCVTestRunner.Log("matches found: " + matches.size());
+        // for (DMatch m : matches)
+        // OpenCVTestRunner.Log(m.toString());
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n");
+
+        matcher.read(filename);
+        assertTrue(true);// BruteforceMatcher has no settings
+    }
+
+    public void testTrain() {
+        matcher.train();// BruteforceMatcher does not need to train
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        String truth = "%YAML:1.0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/DENSEFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DENSEFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicDENSEFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicDENSEFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicFASTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicFASTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicGFTTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicGFTTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicHARRISFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicHARRISFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicMSERFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicMSERFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicORBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicORBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicSIFTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicSIFTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicSIMPLEBLOBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicSIMPLEBLOBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicSTARFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicSTARFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/DynamicSURFFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class DynamicSURFFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/FASTFeatureDetectorTest.java

@@ -0,0 +1,146 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class FASTFeatureDetectorTest extends OpenCVTestCase {
+
+    FeatureDetector detector;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(100, 100, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, 100, 50, 100);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Mat img = new Mat(100, 100, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(img, new Point(30, 30), new Point(70, 70), new Scalar(0), 8);
+        return img;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = FeatureDetector.create(FeatureDetector.FAST);
+        truth = new KeyPoint[] { new KeyPoint(32, 27, 7, -1, 254, 0, -1), new KeyPoint(27, 32, 7, -1, 254, 0, -1), new KeyPoint(73, 68, 7, -1, 254, 0, -1),
+                new KeyPoint(68, 73, 7, -1, 254, 0, -1) };
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        Mat img = getTestImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints);
+
+        assertListKeyPointEquals(Arrays.asList(truth), keypoints.toList(), EPS);
+
+        // OpenCVTestRunner.Log("points found: " + keypoints.size());
+        // for (KeyPoint kp : keypoints)
+        // OpenCVTestRunner.Log(kp.toString());
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints, mask);
+
+        assertListKeyPointEquals(Arrays.asList(truth[0], truth[1]), keypoints.toList(), EPS);
+    }
+
+    public void testEmpty() {
+        assertFalse(detector.empty());
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        writeFile(filename, "%YAML:1.0\nthreshold: 130\nnonmaxSuppression: 1\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+
+        detector.detect(grayChess, keypoints1);
+
+        writeFile(filename, "%YAML:1.0\nthreshold: 150\nnonmaxSuppression: 1\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
+
+        detector.detect(grayChess, keypoints2);
+
+        assertTrue(keypoints2.total() <= keypoints1.total());
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        writeFile(filename,
+                "<?xml version=\"1.0\"?>\n<opencv_storage>\n<threshold>130</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n</opencv_storage>\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+
+        detector.detect(grayChess, keypoints1);
+
+        writeFile(filename,
+                "<?xml version=\"1.0\"?>\n<opencv_storage>\n<threshold>150</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n</opencv_storage>\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
+
+        detector.detect(grayChess, keypoints2);
+
+        assertTrue(keypoints2.total() <= keypoints1.total());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        detector.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.FAST</name>\n<nonmaxSuppression>1</nonmaxSuppression>\n<threshold>10</threshold>\n<type>2</type>\n</opencv_storage>\n";
+        String data = readFile(filename);
+        //Log.d("qqq", "\"" + data + "\"");
+        assertEquals(truth, data);
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\nname: \"Feature2D.FAST\"\nnonmaxSuppression: 1\nthreshold: 10\ntype: 2\n";
+        String data = readFile(filename);
+
+        //Log.d("qqq", "\"" + data + "\"");
+        assertEquals(truth, data);
+    }
+}

modules/features2d/misc/java/test/Features2dTest.java

@@ -0,0 +1,145 @@
+package org.opencv.test.features2d;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.calib3d.Calib3d;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.Point;
+import org.opencv.core.Range;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.features2d.Features2d;
+import org.opencv.core.KeyPoint;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+
+public class Features2dTest extends OpenCVTestCase {
+
+    public void testDrawKeypointsMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawKeypointsMatListOfKeyPointMatScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawKeypointsMatListOfKeyPointMatScalarInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalarScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalarScalarListOfListOfByte() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatches2MatListOfKeyPointMatListOfKeyPointListOfListOfDMatchMatScalarScalarListOfListOfByteInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalarScalar() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalarScalarListOfByte() {
+        fail("Not yet implemented");
+    }
+
+    public void testDrawMatchesMatListOfKeyPointMatListOfKeyPointListOfDMatchMatScalarScalarListOfByteInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testPTOD()
+    {
+        String detectorCfg = "%YAML:1.0\nhessianThreshold: 4000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n";
+        String extractorCfg = "%YAML:1.0\nnOctaves: 4\nnOctaveLayers: 2\nextended: 0\nupright: 0\n";
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+        DescriptorMatcher matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE);
+
+        String detectorCfgFile = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(detectorCfgFile, detectorCfg);
+        detector.read(detectorCfgFile);
+
+        String extractorCfgFile = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(extractorCfgFile, extractorCfg);
+        extractor.read(extractorCfgFile);
+
+        Mat imgTrain = Imgcodecs.imread(OpenCVTestRunner.LENA_PATH, Imgcodecs.CV_LOAD_IMAGE_GRAYSCALE);
+        Mat imgQuery = imgTrain.submat(new Range(0, imgTrain.rows() - 100), Range.all());
+
+        MatOfKeyPoint trainKeypoints = new MatOfKeyPoint();
+        MatOfKeyPoint queryKeypoints = new MatOfKeyPoint();
+
+        detector.detect(imgTrain, trainKeypoints);
+        detector.detect(imgQuery, queryKeypoints);
+
+        // OpenCVTestRunner.Log("Keypoints found: " + trainKeypoints.size() +
+        // ":" + queryKeypoints.size());
+
+        Mat trainDescriptors = new Mat();
+        Mat queryDescriptors = new Mat();
+
+        extractor.compute(imgTrain, trainKeypoints, trainDescriptors);
+        extractor.compute(imgQuery, queryKeypoints, queryDescriptors);
+
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.add(Arrays.asList(trainDescriptors));
+        matcher.match(queryDescriptors, matches);
+
+        // OpenCVTestRunner.Log("Matches found: " + matches.size());
+
+        DMatch adm[] = matches.toArray();
+        List<Point> lp1 = new ArrayList<Point>(adm.length);
+        List<Point> lp2 = new ArrayList<Point>(adm.length);
+        KeyPoint tkp[] = trainKeypoints.toArray();
+        KeyPoint qkp[] = queryKeypoints.toArray();
+        for (int i = 0; i < adm.length; i++) {
+            DMatch dm = adm[i];
+            lp1.add(tkp[dm.trainIdx].pt);
+            lp2.add(qkp[dm.queryIdx].pt);
+        }
+
+        MatOfPoint2f points1 = new MatOfPoint2f(lp1.toArray(new Point[0]));
+        MatOfPoint2f points2 = new MatOfPoint2f(lp2.toArray(new Point[0]));
+
+        Mat hmg = Calib3d.findHomography(points1, points2, Calib3d.RANSAC, 3);
+
+        assertMatEqual(Mat.eye(3, 3, CvType.CV_64F), hmg, EPS);
+
+        Mat outimg = new Mat();
+        Features2d.drawMatches(imgQuery, queryKeypoints, imgTrain, trainKeypoints, matches, outimg);
+        String outputPath = OpenCVTestRunner.getOutputFileName("PTODresult.png");
+        Imgcodecs.imwrite(outputPath, outimg);
+        // OpenCVTestRunner.Log("Output image is saved to: " + outputPath);
+    }
+}

modules/features2d/misc/java/test/FernGenericDescriptorMatcherTest.java

@@ -0,0 +1,127 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class FernGenericDescriptorMatcherTest extends OpenCVTestCase {
+
+    public void testAdd() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPointMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCloneBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testClone() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainImages() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainKeypoints() {
+        fail("Not yet implemented");
+    }
+
+    public void testIsMaskSupported() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatchListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/FlannBasedDescriptorMatcherTest.java

@@ -0,0 +1,366 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvException;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfDMatch;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class FlannBasedDescriptorMatcherTest extends OpenCVTestCase {
+
+    static final String xmlParamsDefault = "<?xml version=\"1.0\"?>\n"
+            + "<opencv_storage>\n"
+            + "<indexParams>\n"
+            + "  <_>\n"
+            + "    <name>algorithm</name>\n"
+            + "    <type>23</type>\n"
+            + "    <value>1</value></_>\n"
+            + "  <_>\n"
+            + "    <name>trees</name>\n"
+            + "    <type>4</type>\n"
+            + "    <value>4</value></_></indexParams>\n"
+            + "<searchParams>\n"
+            + "  <_>\n"
+            + "    <name>checks</name>\n"
+            + "    <type>4</type>\n"
+            + "    <value>32</value></_>\n"
+            + "  <_>\n"
+            + "    <name>eps</name>\n"
+            + "    <type>5</type>\n"
+            + "    <value>0.</value></_>\n"
+            + "  <_>\n"
+            + "    <name>sorted</name>\n"
+            + "    <type>15</type>\n"
+            + "    <value>1</value></_></searchParams>\n"
+            + "</opencv_storage>\n";
+    static final String ymlParamsDefault = "%YAML:1.0\n"
+            + "indexParams:\n"
+            + "   -\n"
+            + "      name: algorithm\n"
+            + "      type: 23\n"
+            + "      value: 1\n"
+            + "   -\n"
+            + "      name: trees\n"
+            + "      type: 4\n"
+            + "      value: 4\n"
+            + "searchParams:\n"
+            + "   -\n"
+            + "      name: checks\n"
+            + "      type: 4\n"
+            + "      value: 32\n"
+            + "   -\n"
+            + "      name: eps\n"
+            + "      type: 5\n"
+            + "      value: 0.\n"
+            + "   -\n"
+            + "      name: sorted\n"
+            + "      type: 15\n"
+            + "      value: 1\n";
+    static final String ymlParamsModified = "%YAML:1.0\n"
+            + "indexParams:\n"
+            + "   -\n"
+            + "      name: algorithm\n"
+            + "      type: 23\n"
+            + "      value: 6\n"// this line is changed!
+            + "   -\n"
+            + "      name: trees\n"
+            + "      type: 4\n"
+            + "      value: 4\n"
+            + "searchParams:\n"
+            + "   -\n"
+            + "      name: checks\n"
+            + "      type: 4\n"
+            + "      value: 32\n"
+            + "   -\n"
+            + "      name: eps\n"
+            + "      type: 5\n"
+            + "      value: 4.\n"// this line is changed!
+            + "   -\n"
+            + "      name: sorted\n"
+            + "      type: 15\n"
+            + "      value: 1\n";
+
+    DescriptorMatcher matcher;
+
+    int matSize;
+
+    DMatch[] truth;
+
+    private Mat getMaskImg() {
+        return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
+            {
+                put(0, 0, 1, 1, 1, 1);
+            }
+        };
+    }
+
+    private Mat getQueryDescriptors() {
+        Mat img = getQueryImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat descriptors = new Mat();
+
+        FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        detector.detect(img, keypoints);
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getQueryImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
+        Imgproc.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
+
+        return cross;
+    }
+
+    private Mat getTrainDescriptors() {
+        Mat img = getTrainImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
+        Mat descriptors = new Mat();
+
+        DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        return descriptors;
+    }
+
+    private Mat getTrainImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        matcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
+        matSize = 100;
+        truth = new DMatch[] {
+                new DMatch(0, 0, 0, 0.6211397f),
+                new DMatch(1, 1, 0, 0.9177120f),
+                new DMatch(2, 1, 0, 0.3112163f),
+                new DMatch(3, 1, 0, 0.2925075f),
+                new DMatch(4, 1, 0, 0.9309179f)
+                };
+    }
+
+    public void testAdd() {
+        matcher.add(Arrays.asList(new Mat()));
+        assertFalse(matcher.empty());
+    }
+
+    public void testClear() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        matcher.clear();
+
+        assertTrue(matcher.empty());
+    }
+
+    public void testClone() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        matcher.add(Arrays.asList(train));
+
+        try {
+            matcher.clone();
+            fail("Expected CvException (CV_StsNotImplemented)");
+        } catch (CvException cverr) {
+            // expected
+        }
+    }
+
+    public void testCloneBoolean() {
+        matcher.add(Arrays.asList(new Mat()));
+
+        DescriptorMatcher cloned = matcher.clone(true);
+
+        assertNotNull(cloned);
+        assertTrue(cloned.empty());
+    }
+
+    public void testCreate() {
+        assertNotNull(matcher);
+    }
+
+    public void testEmpty() {
+        assertTrue(matcher.empty());
+    }
+
+    public void testGetTrainDescriptors() {
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        Mat truth = train.clone();
+        matcher.add(Arrays.asList(train));
+
+        List<Mat> descriptors = matcher.getTrainDescriptors();
+
+        assertEquals(1, descriptors.size());
+        assertMatEqual(truth, descriptors.get(0));
+    }
+
+    public void testIsMaskSupported() {
+        assertFalse(matcher.isMaskSupported());
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+        matcher.train();
+
+        matcher.match(query, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatListOfDMatchListOfMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+        matcher.add(Arrays.asList(train));
+        matcher.train();
+
+        matcher.match(query, matches, Arrays.asList(mask));
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+    }
+
+    public void testMatchMatMatListOfDMatch() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches);
+
+        assertArrayDMatchEquals(truth, matches.toArray(), EPS);
+
+        // OpenCVTestRunner.Log(matches.toString());
+        // OpenCVTestRunner.Log(matches);
+    }
+
+    public void testMatchMatMatListOfDMatchMat() {
+        Mat train = getTrainDescriptors();
+        Mat query = getQueryDescriptors();
+        Mat mask = getMaskImg();
+        MatOfDMatch matches = new MatOfDMatch();
+
+        matcher.match(query, train, matches, mask);
+
+        assertListDMatchEquals(Arrays.asList(truth), matches.toList(), EPS);
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        String filenameR = OpenCVTestRunner.getTempFileName("yml");
+        String filenameW = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filenameR, ymlParamsModified);
+
+        matcher.read(filenameR);
+        matcher.write(filenameW);
+
+        assertEquals(ymlParamsModified, readFile(filenameW));
+    }
+
+    public void testTrain() {
+        Mat train = getTrainDescriptors();
+        matcher.add(Arrays.asList(train));
+        matcher.train();
+    }
+
+    public void testTrainNoData() {
+        try {
+            matcher.train();
+            fail("Expected CvException - FlannBasedMatcher::train should fail on empty train set");
+        } catch (CvException cverr) {
+            // expected
+        }
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        matcher.write(filename);
+
+        assertEquals(xmlParamsDefault, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        matcher.write(filename);
+
+        assertEquals(ymlParamsDefault, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/GFTTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GFTTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridDENSEFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridDENSEFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridFASTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridFASTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridGFTTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridGFTTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridHARRISFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridHARRISFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridMSERFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridMSERFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridORBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridORBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridSIFTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridSIFTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridSIMPLEBLOBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridSIMPLEBLOBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridSTARFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridSTARFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/GridSURFFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class GridSURFFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/HARRISFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class HARRISFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/MSERFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class MSERFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/ORBDescriptorExtractorTest.java

@@ -0,0 +1,120 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class ORBDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    int matSize;
+
+    public static void assertDescriptorsClose(Mat expected, Mat actual, int allowedDistance) {
+        double distance = Core.norm(expected, actual, Core.NORM_HAMMING);
+        assertTrue("expected:<" + allowedDistance + "> but was:<" + distance + ">", distance <= allowedDistance);
+    }
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = DescriptorExtractor.create(DescriptorExtractor.ORB);
+        matSize = 100;
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 32, CvType.CV_8UC1) {
+            {
+                put(0, 0,
+                        6, 74, 6, 129, 2, 130, 56, 0, 36, 132, 66, 165, 172, 6, 3, 72, 102, 61, 163, 214, 0, 144, 65, 232, 4, 32, 138, 129, 4, 21, 37, 88);
+            }
+        };
+        assertDescriptorsClose(truth, descriptors, 1);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(32, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_8U, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nscaleFactor: 1.1\nnLevels: 3\nfirstLevel: 0\nedgeThreshold: 31\npatchSize: 31\n");
+        extractor.read(filename);
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 32, CvType.CV_8UC1) {
+            {
+                put(0, 0,
+                        6, 10, 22, 5, 2, 130, 56, 0, 44, 164, 66, 165, 140, 6, 1, 72, 38, 61, 163, 210, 0, 208, 1, 104, 4, 32, 10, 131, 0, 37, 37, 67);
+            }
+        };
+        assertDescriptorsClose(truth, descriptors, 1);
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.ORB</name>\n<WTA_K>2</WTA_K>\n<edgeThreshold>31</edgeThreshold>\n<firstLevel>0</firstLevel>\n<nFeatures>500</nFeatures>\n<nLevels>8</nLevels>\n<patchSize>31</patchSize>\n<scaleFactor>1.2000000476837158e+00</scaleFactor>\n<scoreType>0</scoreType>\n</opencv_storage>\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e\\+000", "e+00"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\nname: \"Feature2D.ORB\"\nWTA_K: 2\nedgeThreshold: 31\nfirstLevel: 0\nnFeatures: 500\nnLevels: 8\npatchSize: 31\nscaleFactor: 1.2000000476837158e+00\nscoreType: 0\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e\\+000", "e+00"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}

modules/features2d/misc/java/test/ORBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class ORBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/OneWayGenericDescriptorMatcherTest.java

@@ -0,0 +1,127 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class OneWayGenericDescriptorMatcherTest extends OpenCVTestCase {
+
+    public void testAdd() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPointMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClassifyMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testClear() {
+        fail("Not yet implemented");
+    }
+
+    public void testCloneBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testClone() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainImages() {
+        fail("Not yet implemented");
+    }
+
+    public void testGetTrainKeypoints() {
+        fail("Not yet implemented");
+    }
+
+    public void testIsMaskSupported() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchIntMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchIntListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testKnnMatchMatListOfKeyPointListOfListOfDMatchInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatchMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatchListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testMatchMatListOfKeyPointListOfDMatch() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloatMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMatBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloatListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRadiusMatchMatListOfKeyPointListOfListOfDMatchFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testTrain() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/OpponentBRIEFDescriptorExtractorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class OpponentBRIEFDescriptorExtractorTest extends OpenCVTestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/OpponentORBDescriptorExtractorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class OpponentORBDescriptorExtractorTest extends OpenCVTestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/OpponentSIFTDescriptorExtractorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class OpponentSIFTDescriptorExtractorTest extends OpenCVTestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/OpponentSURFDescriptorExtractorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class OpponentSURFDescriptorExtractorTest extends OpenCVTestCase {
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testDescriptorType() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidDENSEFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidDENSEFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidFASTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidFASTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidGFTTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidGFTTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidHARRISFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidHARRISFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidMSERFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidMSERFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidORBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidORBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidSIFTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidSIFTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidSIMPLEBLOBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidSIMPLEBLOBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidSTARFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidSTARFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/PyramidSURFFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class PyramidSURFFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/SIFTDescriptorExtractorTest.java

@@ -0,0 +1,107 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class SIFTDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    KeyPoint keypoint;
+    int matSize;
+    Mat truth;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = DescriptorExtractor.create(DescriptorExtractor.SIFT);
+        keypoint = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        matSize = 100;
+        truth = new Mat(1, 128, CvType.CV_32FC1) {
+            {
+                put(0, 0,
+                          0, 0, 0, 1, 3, 0, 0, 0, 15, 23, 22, 20, 24, 2, 0, 0, 7, 8, 2, 0,
+                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 16, 13, 2, 0, 0, 117,
+                          86, 79, 68, 117, 42, 5, 5, 79, 60, 117, 25, 9, 2, 28, 19, 11, 13,
+                          20, 2, 0, 0, 5, 8, 0, 0, 76, 58, 34, 31, 97, 16, 95, 49, 117, 92,
+                          117, 112, 117, 76, 117, 54, 117, 25, 29, 22, 117, 117, 16, 11, 14,
+                          1, 0, 0, 22, 26, 0, 0, 0, 0, 1, 4, 15, 2, 47, 8, 0, 0, 82, 56, 31,
+                          17, 81, 12, 0, 0, 26, 23, 18, 23, 0, 0, 0, 0, 0, 0, 0, 0
+                   );
+            }
+        };
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(keypoint);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        assertMatEqual(truth, descriptors, EPS);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(128, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_32F, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.SIFT</name>\n<contrastThreshold>4.0000000000000001e-02</contrastThreshold>\n<edgeThreshold>10.</edgeThreshold>\n<nFeatures>0</nFeatures>\n<nOctaveLayers>3</nOctaveLayers>\n<sigma>1.6000000000000001e+00</sigma>\n</opencv_storage>\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\nname: \"Feature2D.SIFT\"\ncontrastThreshold: 4.0000000000000001e-02\nedgeThreshold: 10.\nnFeatures: 0\nnOctaveLayers: 3\nsigma: 1.6000000000000001e+00\n";
+        String actual = readFile(filename);
+        actual = actual.replaceAll("e([+-])0(\\d\\d)", "e$1$2"); // NOTE: workaround for different platforms double representation
+        assertEquals(truth, actual);
+    }
+
+}

modules/features2d/misc/java/test/SIFTFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class SIFTFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/SIMPLEBLOBFeatureDetectorTest.java

@@ -0,0 +1,39 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+
+public class SIMPLEBLOBFeatureDetectorTest extends OpenCVTestCase {
+
+    public void testCreate() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testEmpty() {
+        fail("Not yet implemented");
+    }
+
+    public void testRead() {
+        fail("Not yet implemented");
+    }
+
+    public void testWrite() {
+        fail("Not yet implemented");
+    }
+
+}

modules/features2d/misc/java/test/STARFeatureDetectorTest.java

@@ -0,0 +1,131 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class STARFeatureDetectorTest extends OpenCVTestCase {
+
+    FeatureDetector detector;
+    int matSize;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, matSize, matSize / 2, matSize);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Scalar color = new Scalar(0);
+        int center = matSize / 2;
+        int radius = 6;
+        int offset = 40;
+
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.circle(img, new Point(center - offset, center), radius, color, -1);
+        Imgproc.circle(img, new Point(center + offset, center), radius, color, -1);
+        Imgproc.circle(img, new Point(center, center - offset), radius, color, -1);
+        Imgproc.circle(img, new Point(center, center + offset), radius, color, -1);
+        Imgproc.circle(img, new Point(center, center), radius, color, -1);
+        return img;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = FeatureDetector.create(FeatureDetector.STAR);
+        matSize = 200;
+        truth = new KeyPoint[] {
+                new KeyPoint( 95,  80, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(105,  80, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint( 80,  95, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(120,  95, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(100, 100,  8, -1, 30.f,     0, -1),
+                new KeyPoint( 80, 105, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(120, 105, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint( 95, 120, 22, -1, 31.5957f, 0, -1),
+                new KeyPoint(105, 120, 22, -1, 31.5957f, 0, -1)
+            };
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        Mat img = getTestImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints);
+
+        assertListKeyPointEquals(Arrays.asList(truth), keypoints.toList(), EPS);
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints, mask);
+
+        assertListKeyPointEquals(Arrays.asList(truth[0], truth[2], truth[5], truth[7]), keypoints.toList(), EPS);
+    }
+
+    public void testEmpty() {
+        assertFalse(detector.empty());
+    }
+
+    public void testRead() {
+        Mat img = getTestImg();
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+        detector.detect(img, keypoints1);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nmaxSize: 45\nresponseThreshold: 150\nlineThresholdProjected: 10\nlineThresholdBinarized: 8\nsuppressNonmaxSize: 5\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
+        detector.detect(img, keypoints2);
+
+        assertTrue(keypoints2.total() <= keypoints1.total());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        detector.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.STAR</name>\n<lineThresholdBinarized>8</lineThresholdBinarized>\n<lineThresholdProjected>10</lineThresholdProjected>\n<maxSize>45</maxSize>\n<responseThreshold>30</responseThreshold>\n<suppressNonmaxSize>5</suppressNonmaxSize>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\nname: \"Feature2D.STAR\"\nlineThresholdBinarized: 8\nlineThresholdProjected: 10\nmaxSize: 45\nresponseThreshold: 30\nsuppressNonmaxSize: 5\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/SURFDescriptorExtractorTest.java

@@ -0,0 +1,118 @@
+package org.opencv.test.features2d;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.DescriptorExtractor;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class SURFDescriptorExtractorTest extends OpenCVTestCase {
+
+    DescriptorExtractor extractor;
+    int matSize;
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nextended: 1\nhessianThreshold: 100.\nnOctaveLayers: 2\nnOctaves: 4\nupright: 0");
+        extractor.read(filename);
+
+        matSize = 100;
+    }
+
+    public void testComputeListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testComputeMatListOfKeyPointMat() {
+        KeyPoint point = new KeyPoint(55.775577545166016f, 44.224422454833984f, 16, 9.754629f, 8617.863f, 1, -1);
+        MatOfKeyPoint keypoints = new MatOfKeyPoint(point);
+        Mat img = getTestImg();
+        Mat descriptors = new Mat();
+
+        extractor.compute(img, keypoints, descriptors);
+
+        Mat truth = new Mat(1, 128, CvType.CV_32FC1) {
+            {
+                put(0, 0,
+                          0, 0, 0, 0, 0, 0, 0, 0, 0.058821894, 0.058821894, -0.045962855, 0.046261817, 0.0085156476,
+                          0.0085754395, -0.0064509804, 0.0064509804, 0.00044069235, 0.00044069235, 0, 0, 0.00025723741,
+                          0.00025723741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00025723741, 0.00025723741, -0.00044069235,
+                          0.00044069235, 0, 0, 0.36278215, 0.36278215, -0.24688604, 0.26173124, 0.052068226, 0.052662034,
+                          -0.032815345, 0.032815345, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.0064523756,
+                          0.0064523756, 0.0082002236, 0.0088908644, -0.059001274, 0.059001274, 0.045789491, 0.04648013,
+                          0.11961588, 0.22789426, -0.01322381, 0.18291828, -0.14042182, 0.23973691, 0.073782086, 0.23769434,
+                          -0.027880307, 0.027880307, 0.049587864, 0.049587864, -0.33991757, 0.33991757, 0.21437603, 0.21437603,
+                          -0.0020763327, 0.0020763327, 0.006245892, 0.006245892, -0.04067041, 0.04067041, 0.019361559,
+                          0.019361559, 0, 0, -0.0035977389, 0.0035977389, 0, 0, -0.00099993451, 0.00099993451, 0.040670406,
+                          0.040670406, -0.019361559, 0.019361559, 0.006245892, 0.006245892, -0.0020763327, 0.0020763327,
+                          -0.00034532088, 0.00034532088, 0, 0, 0, 0, 0.00034532088, 0.00034532088, -0.00099993451,
+                          0.00099993451, 0, 0, 0, 0, 0.0035977389, 0.0035977389
+                    );
+            }
+        };
+
+        assertMatEqual(truth, descriptors, EPS);
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    public void testDescriptorSize() {
+        assertEquals(128, extractor.descriptorSize());
+    }
+
+    public void testDescriptorType() {
+        assertEquals(CvType.CV_32F, extractor.descriptorType());
+    }
+
+    public void testEmpty() {
+        assertFalse(extractor.empty());
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nnOctaves: 4\nnOctaveLayers: 2\nextended: 1\nupright: 0\n");
+
+        extractor.read(filename);
+
+        assertEquals(128, extractor.descriptorSize());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        extractor.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.SURF</name>\n<extended>1</extended>\n<hessianThreshold>100.</hessianThreshold>\n<nOctaveLayers>2</nOctaveLayers>\n<nOctaves>4</nOctaves>\n<upright>0</upright>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\nname: \"Feature2D.SURF\"\nextended: 1\nhessianThreshold: 100.\nnOctaveLayers: 2\nnOctaves: 4\nupright: 0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/SURFFeatureDetectorTest.java

@@ -0,0 +1,167 @@
+package org.opencv.test.features2d;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import org.opencv.core.Core;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Point;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.FeatureDetector;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class SURFFeatureDetectorTest extends OpenCVTestCase {
+
+    FeatureDetector detector;
+    int matSize;
+    KeyPoint[] truth;
+
+    private Mat getMaskImg() {
+        Mat mask = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Mat right = mask.submat(0, matSize, matSize / 2, matSize);
+        right.setTo(new Scalar(0));
+        return mask;
+    }
+
+    private Mat getTestImg() {
+        Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
+        Imgproc.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
+
+        return cross;
+    }
+
+    private void order(List<KeyPoint> points) {
+        Collections.sort(points, new Comparator<KeyPoint>() {
+            public int compare(KeyPoint p1, KeyPoint p2) {
+                if (p1.angle < p2.angle)
+                    return -1;
+                if (p1.angle > p2.angle)
+                    return 1;
+                return 0;
+            }
+        });
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = FeatureDetector.create(FeatureDetector.SURF);
+        matSize = 100;
+        truth = new KeyPoint[] {
+                new KeyPoint(55.775578f, 55.775578f, 16, 80.245735f, 8617.8633f, 0, -1),
+                new KeyPoint(44.224422f, 55.775578f, 16, 170.24574f, 8617.8633f, 0, -1),
+                new KeyPoint(44.224422f, 44.224422f, 16, 260.24573f, 8617.8633f, 0, -1),
+                new KeyPoint(55.775578f, 44.224422f, 16, 350.24573f, 8617.8633f, 0, -1)
+            };
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPoint() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        List<MatOfKeyPoint> keypoints = new ArrayList<MatOfKeyPoint>();
+        Mat cross = getTestImg();
+        List<Mat> crosses = new ArrayList<Mat>(3);
+        crosses.add(cross);
+        crosses.add(cross);
+        crosses.add(cross);
+
+        detector.detect(crosses, keypoints);
+
+        assertEquals(3, keypoints.size());
+
+        for (MatOfKeyPoint mkp : keypoints) {
+            List<KeyPoint> lkp = mkp.toList();
+            order(lkp);
+            assertListKeyPointEquals(Arrays.asList(truth), lkp, EPS);
+        }
+    }
+
+    public void testDetectListOfMatListOfListOfKeyPointListOfMat() {
+        fail("Not yet implemented");
+    }
+
+    public void testDetectMatListOfKeyPoint() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        Mat cross = getTestImg();
+
+        detector.detect(cross, keypoints);
+
+        List<KeyPoint> lkp = keypoints.toList();
+        order(lkp);
+        assertListKeyPointEquals(Arrays.asList(truth), lkp, EPS);
+    }
+
+    public void testDetectMatListOfKeyPointMat() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        Mat img = getTestImg();
+        Mat mask = getMaskImg();
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+
+        detector.detect(img, keypoints, mask);
+
+        List<KeyPoint> lkp = keypoints.toList();
+        order(lkp);
+        assertListKeyPointEquals(Arrays.asList(truth[1], truth[2]), lkp, EPS);
+    }
+
+    public void testEmpty() {
+        assertFalse(detector.empty());
+    }
+
+    public void testRead() {
+        Mat cross = getTestImg();
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+        detector.detect(cross, keypoints1);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
+        detector.detect(cross, keypoints2);
+
+        assertTrue(keypoints2.total() <= keypoints1.total());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        detector.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.SURF</name>\n<extended>0</extended>\n<hessianThreshold>100.</hessianThreshold>\n<nOctaveLayers>3</nOctaveLayers>\n<nOctaves>4</nOctaves>\n<upright>0</upright>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\nname: \"Feature2D.SURF\"\nextended: 0\nhessianThreshold: 100.\nnOctaveLayers: 3\nnOctaves: 4\nupright: 0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}