chore: import upstream snapshot with attribution

modules/features2d/misc/java/filelist

@@ -0,0 +1 @@
+include/opencv2/features2d.hpp

modules/features2d/misc/java/filelist_common

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

modules/features2d/misc/java/gen_dict.json

@@ -0,0 +1,18 @@
+{
+    "type_dict" : {
+        "Feature2D": {
+            "j_type": "Feature2D",
+            "jn_type": "long",
+            "jni_type": "jlong",
+            "jni_var": "Feature2D %(n)s",
+            "suffix": "J",
+            "j_import": "org.opencv.features2d.Feature2D"
+        },
+        "uchar": {
+            "j_type": "byte",
+            "jn_type": "byte",
+            "jni_type": "jbyte",
+            "suffix": "B"
+        }
+    }
+}

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,21 @@
+#ifndef __FEATURES2D_CONVERTERS_HPP__
+#define __FEATURES2D_CONVERTERS_HPP__
+
+#include "opencv2/opencv_modules.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/features2d.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/test/AGASTFeatureDetectorTest.java

@@ -0,0 +1,85 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.features2d.AgastFeatureDetector;
+
+public class AGASTFeatureDetectorTest extends OpenCVTestCase {
+
+    AgastFeatureDetector detector;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = AgastFeatureDetector.create(); // default (10,true,3)
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    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() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+        writeFile(filename, "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.AgastFeatureDetector</name>\n<threshold>11</threshold>\n<nonmaxSuppression>0</nonmaxSuppression>\n<type>2</type>\n</opencv_storage>\n");
+
+        detector.read(filename);
+
+        assertEquals(11, detector.getThreshold());
+        assertEquals(false, detector.getNonmaxSuppression());
+        assertEquals(2, detector.getType());
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.AgastFeatureDetector\"\nthreshold: 11\nnonmaxSuppression: 0\ntype: 2\n");
+
+        detector.read(filename);
+
+        assertEquals(11, detector.getThreshold());
+        assertEquals(false, detector.getNonmaxSuppression());
+        assertEquals(2, detector.getType());
+    }
+
+    public void testWrite() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        detector.write(filename);
+
+        String truth = "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.AgastFeatureDetector</name>\n<threshold>10</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n<type>3</type>\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");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.AgastFeatureDetector\"\nthreshold: 10\nnonmaxSuppression: 1\ntype: 3\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/AKAZEDescriptorExtractorTest.java

@@ -0,0 +1,67 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.features2d.AKAZE;
+
+public class AKAZEDescriptorExtractorTest extends OpenCVTestCase {
+
+    AKAZE extractor;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = AKAZE.create(); // default (5,0,3,0.001f,4,4,1)
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    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 testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nformat: 3\nname: \"Feature2D.AKAZE\"\ndescriptor: 4\ndescriptor_channels: 2\ndescriptor_size: 32\nthreshold: 0.125\noctaves: 3\nsublevels: 5\ndiffusivity: 2\n");
+
+        extractor.read(filename);
+
+        assertEquals(4, extractor.getDescriptorType());
+        assertEquals(2, extractor.getDescriptorChannels());
+        assertEquals(32, extractor.getDescriptorSize());
+        assertEquals(0.125, extractor.getThreshold());
+        assertEquals(3, extractor.getNOctaves());
+        assertEquals(5, extractor.getNOctaveLayers());
+        assertEquals(2, extractor.getDiffusivity());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nformat: 3\nname: \"Feature2D.AKAZE\"\ndescriptor: 5\ndescriptor_channels: 3\ndescriptor_size: 0\nthreshold: 0.0010000000474974513\noctaves: 4\nsublevels: 4\ndiffusivity: 1\nmax_points: -1\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/BOWImgDescriptorExtractorTest.java

@@ -0,0 +1,48 @@
+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.core.KeyPoint;
+import org.opencv.features2d.ORB;
+import org.opencv.features2d.DescriptorMatcher;
+import org.opencv.features2d.BOWImgDescriptorExtractor;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class BOWImgDescriptorExtractorTest extends OpenCVTestCase {
+
+    ORB extractor;
+    DescriptorMatcher matcher;
+    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 = ORB.create();
+        matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE);
+        matSize = 100;
+    }
+
+    public void testCreate() {
+        BOWImgDescriptorExtractor bow = new BOWImgDescriptorExtractor(extractor, matcher);
+    }
+
+}

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

@@ -0,0 +1,102 @@
+package org.opencv.test.features2d;
+
+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.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.Feature2D;
+
+public class BRIEFDescriptorExtractorTest extends OpenCVTestCase {
+
+    Feature2D 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 = createClassInstance(XFEATURES2D+"BriefDescriptorExtractor", DEFAULT_FACTORY, null, null);
+        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());
+        fail("Not yet implemented"); // BRIEF does not override empty() method
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\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<name>Feature2D.BRIEF</name>\n<descriptorSize>32</descriptorSize>\n<use_orientation>0</use_orientation>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.BRIEF\"\ndescriptorSize: 32\nuse_orientation: 0\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

modules/features2d/misc/java/test/BRISKDescriptorExtractorTest.java

@@ -0,0 +1,63 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.features2d.BRISK;
+
+public class BRISKDescriptorExtractorTest extends OpenCVTestCase {
+
+    BRISK extractor;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = BRISK.create(); // default (30,3,1)
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    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 testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.BRISK\"\nthreshold: 31\noctaves: 4\npatternScale: 1.1\n");
+
+        extractor.read(filename);
+
+        assertEquals(31, extractor.getThreshold());
+        assertEquals(4, extractor.getOctaves());
+        assertEquals(1.1f, extractor.getPatternScale());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.BRISK\"\nthreshold: 30\noctaves: 3\npatternScale: 1.\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/BruteForceDescriptorMatcherTest.java

@@ -0,0 +1,304 @@
+package org.opencv.test.features2d;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+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.DescriptorMatcher;
+import org.opencv.features2d.BFMatcher;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.Feature2D;
+
+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();
+
+        Feature2D detector = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        setProperty(detector, "hessianThreshold", "double", 8000);
+        setProperty(detector, "nOctaves", "int", 3);
+        setProperty(detector, "nOctaveLayers", "int", 4);
+        setProperty(detector, "upright", "boolean", false);
+
+        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();
+
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        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.6159003f),
+                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.26520672f)
+                };
+    }
+
+    // https://github.com/opencv/opencv/issues/11268
+    public void testConstructor()
+    {
+        BFMatcher self_created_matcher = new BFMatcher();
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        self_created_matcher.add(Arrays.asList(train));
+        assertTrue(!self_created_matcher.empty());
+    }
+
+    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---\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---\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

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

@@ -0,0 +1,262 @@
+package org.opencv.test.features2d;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+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.DescriptorMatcher;
+import org.opencv.features2d.FastFeatureDetector;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.Feature2D;
+
+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();
+
+        Feature2D detector = FastFeatureDetector.create();
+        Feature2D extractor = createClassInstance(XFEATURES2D+"BriefDescriptorExtractor", DEFAULT_FACTORY, null, null);
+
+        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(4, matches.size());
+        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---\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---\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

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

@@ -0,0 +1,257 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+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.DescriptorMatcher;
+import org.opencv.features2d.FastFeatureDetector;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.Feature2D;
+
+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();
+
+        Feature2D detector = FastFeatureDetector.create();
+        Feature2D extractor = createClassInstance(XFEATURES2D+"BriefDescriptorExtractor", DEFAULT_FACTORY, null, null);
+
+        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---\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---\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

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

@@ -0,0 +1,268 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+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.DescriptorMatcher;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.Feature2D;
+
+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();
+
+        Feature2D detector = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        setProperty(detector, "extended", "boolean", true);
+        setProperty(detector, "hessianThreshold", "double", 8000);
+        setProperty(detector, "nOctaveLayers", "int", 2);
+        setProperty(detector, "nOctaves", "int", 3);
+        setProperty(detector, "upright", "boolean", false);
+
+        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();
+
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        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.0710702f),
+                new DMatch(1, 1, 0, 3.562016f),
+                new DMatch(2, 1, 0, 1.3682679f),
+                new DMatch(3, 1, 0, 1.3012862f),
+                new DMatch(4, 1, 0, 1.1852086f)
+                };
+    }
+
+    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---\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---\n";
+        assertEquals(truth, readFile(filename));
+    }
+
+}

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

@@ -0,0 +1,280 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+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.DescriptorMatcher;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.Feature2D;
+
+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();
+
+        Feature2D detector = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        setProperty(detector, "hessianThreshold", "double", 8000);
+        setProperty(detector, "nOctaves", "int", 3);
+        setProperty(detector, "nOctaveLayers", "int", 4);
+        setProperty(detector, "upright", "boolean", false);
+
+        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();
+
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        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.37933317f),
+                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.07033461f)
+                };
+    }
+
+    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---\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---\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/FASTFeatureDetectorTest.java

@@ -0,0 +1,141 @@
+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.FastFeatureDetector;
+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 {
+
+    FastFeatureDetector 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 = FastFeatureDetector.create();
+        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());
+        fail("Not yet implemented"); // FAST does not override empty() method
+    }
+
+    public void testRead() {
+        String filename = OpenCVTestRunner.getTempFileName("xml");
+
+        writeFile(filename, "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.FastFeatureDetector</name>\n<threshold>10</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n<type>2</type>\n</opencv_storage>\n");
+        detector.read(filename);
+
+        assertEquals(10, detector.getThreshold());
+        assertEquals(true, detector.getNonmaxSuppression());
+        assertEquals(2, detector.getType());
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+
+        detector.detect(grayChess, keypoints1);
+
+        writeFile(filename, "<?xml version=\"1.0\"?>\n<opencv_storage>\n<name>Feature2D.FastFeatureDetector</name>\n<threshold>150</threshold>\n<nonmaxSuppression>1</nonmaxSuppression>\n<type>2</type>\n</opencv_storage>\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, "%YAML:1.0\n---\nthreshold: 130\nnonmaxSuppression: 1\ntype: 2\n");
+        detector.read(filename);
+
+        assertEquals(130, detector.getThreshold());
+        assertEquals(true, detector.getNonmaxSuppression());
+        assertEquals(2, detector.getType());
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+
+        detector.detect(grayChess, keypoints1);
+
+        writeFile(filename, "%YAML:1.0\n---\nthreshold: 150\nnonmaxSuppression: 1\ntype: 2\n");
+        detector.read(filename);
+
+        MatOfKeyPoint keypoints2 = new MatOfKeyPoint();
+
+        detector.detect(grayChess, keypoints2);
+
+        assertTrue(keypoints2.total() <= keypoints1.total());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.FastFeatureDetector\"\nthreshold: 10\nnonmaxSuppression: 1\ntype: 2\n";
+        String data = readFile(filename);
+
+        assertEquals(truth, data);
+    }
+}

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

@@ -0,0 +1,172 @@
+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.MatOfInt;
+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.Scalar;
+import org.opencv.core.DMatch;
+import org.opencv.features2d.DescriptorMatcher;
+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;
+import org.opencv.features2d.Feature2D;
+
+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\n---\nhessianThreshold: 4000.\nextended: 0\nupright: 0\nOctaves: 4\nOctaveLayers: 3\n";
+        String extractorCfg = "%YAML:1.0\n---\nhessianThreshold: 4000.\nextended: 0\nupright: 0\nOctaves: 4\nOctaveLayers: 3\n";
+
+        Feature2D detector = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+        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.IMREAD_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);
+    }
+
+    public void testDrawKeypoints()
+    {
+        Mat outImg = Mat.ones(11, 11, CvType.CV_8U);
+
+        MatOfKeyPoint kps = new MatOfKeyPoint(new KeyPoint(5, 5, 1));  // x, y, size
+        Features2d.drawKeypoints(new Mat(), kps, outImg, new Scalar(255),
+                                 Features2d.DrawMatchesFlags_DRAW_OVER_OUTIMG);
+
+        Mat ref = new MatOfInt(new int[] {
+            1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
+            1,   1,   1,   1,  15,  54,  15,   1,   1,   1,   1,
+            1,   1,   1,  76, 217, 217, 221,  81,   1,   1,   1,
+            1,   1, 100, 224, 111,  57, 115, 225, 101,   1,   1,
+            1,  44, 215, 100,   1,   1,   1, 101, 214,  44,   1,
+            1,  54, 212,  57,   1,   1,   1,  55, 212,  55,   1,
+            1,  40, 215, 104,   1,   1,   1, 105, 215,  40,   1,
+            1,   1, 102, 221, 111,  55, 115, 222, 103,   1,   1,
+            1,   1,   1,  76, 218, 217, 220,  81,   1,   1,   1,
+            1,   1,   1,   1,  15,  55,  15,   1,   1,   1,   1,
+            1,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1
+        }).reshape(1, 11);
+        ref.convertTo(ref, CvType.CV_8U);
+
+        assertMatEqual(ref, outImg);
+    }
+}

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

@@ -0,0 +1,389 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+import java.util.List;
+
+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.DescriptorMatcher;
+import org.opencv.features2d.FlannBasedMatcher;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.Feature2D;
+
+public class FlannBasedDescriptorMatcherTest extends OpenCVTestCase {
+
+    static final String xmlParamsDefault = "<?xml version=\"1.0\"?>\n"
+            + "<opencv_storage>\n"
+            + "<format>3</format>\n"
+            + "<indexParams>\n"
+            + "  <_>\n"
+            + "    <name>algorithm</name>\n"
+            + "    <type>9</type>\n"  // FLANN_INDEX_TYPE_ALGORITHM
+            + "    <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>explore_all_trees</name>\n"
+            + "    <type>8</type>\n"
+            + "    <value>0</value></_>\n"
+            + "  <_>\n"
+            + "    <name>sorted</name>\n"
+            + "    <type>8</type>\n"  // FLANN_INDEX_TYPE_BOOL
+            + "    <value>1</value></_></searchParams>\n"
+            + "</opencv_storage>\n";
+    static final String ymlParamsDefault = "%YAML:1.0\n---\n"
+            + "format: 3\n"
+            + "indexParams:\n"
+            + "   -\n"
+            + "      name: algorithm\n"
+            + "      type: 9\n"  // FLANN_INDEX_TYPE_ALGORITHM
+            + "      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: explore_all_trees\n"
+            + "      type: 8\n"
+            + "      value: 0\n"
+            + "   -\n"
+            + "      name: sorted\n"
+            + "      type: 8\n"  // FLANN_INDEX_TYPE_BOOL
+            + "      value: 1\n";
+    static final String ymlParamsModified = "%YAML:1.0\n---\n"
+            + "format: 3\n"
+            + "indexParams:\n"
+            + "   -\n"
+            + "      name: algorithm\n"
+            + "      type: 9\n"  // FLANN_INDEX_TYPE_ALGORITHM
+            + "      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: explore_all_trees\n"
+            + "      type: 8\n"
+            + "      value: 1\n"// this line is changed!
+            + "   -\n"
+            + "      name: sorted\n"
+            + "      type: 8\n"    // FLANN_INDEX_TYPE_BOOL
+            + "      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();
+
+        Feature2D detector = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        setProperty(detector, "hessianThreshold", "double", 8000);
+        setProperty(detector, "nOctaves", "int", 3);
+        setProperty(detector, "upright", "boolean", false);
+
+        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();
+
+        Feature2D extractor = createClassInstance(XFEATURES2D+"SURF", DEFAULT_FACTORY, null, null);
+
+        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.6159003f),
+                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.26520672f)
+                };
+    }
+
+    // https://github.com/opencv/opencv/issues/11268
+    public void testConstructor()
+    {
+        FlannBasedMatcher self_created_matcher = new FlannBasedMatcher();
+        Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
+        self_created_matcher.add(Arrays.asList(train));
+        assertTrue(!self_created_matcher.empty());
+    }
+
+    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,67 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.features2d.GFTTDetector;
+
+public class GFTTFeatureDetectorTest extends OpenCVTestCase {
+
+    GFTTDetector detector;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = GFTTDetector.create(); // default constructor have (1000, 0.01, 1, 3, 3, false, 0.04)
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    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 testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.GFTTDetector\"\nnfeatures: 500\nqualityLevel: 2.0000000000000000e-02\nminDistance: 2.\nblockSize: 4\ngradSize: 5\nuseHarrisDetector: 1\nk: 5.0000000000000000e-02\n");
+        detector.read(filename);
+
+        assertEquals(500, detector.getMaxFeatures());
+        assertEquals(0.02, detector.getQualityLevel());
+        assertEquals(2.0, detector.getMinDistance());
+        assertEquals(4, detector.getBlockSize());
+        assertEquals(5, detector.getGradientSize());
+        assertEquals(true, detector.getHarrisDetector());
+        assertEquals(0.05, detector.getK());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.GFTTDetector\"\nnfeatures: 1000\nqualityLevel: 0.01\nminDistance: 1.\nblockSize: 3\ngradSize: 3\nuseHarrisDetector: 0\nk: 0.040000000000000001\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/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/KAZEDescriptorExtractorTest.java

@@ -0,0 +1,66 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.features2d.KAZE;
+
+public class KAZEDescriptorExtractorTest extends OpenCVTestCase {
+
+    KAZE extractor;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        extractor = KAZE.create(); // default (false,false,0.001f,4,4,1)
+    }
+
+    public void testCreate() {
+        assertNotNull(extractor);
+    }
+
+    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 testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nformat: 3\nname: \"Feature2D.KAZE\"\nextended: 1\nupright: 1\nthreshold: 0.125\noctaves: 3\nsublevels: 5\ndiffusivity: 2\n");
+
+        extractor.read(filename);
+
+        assertEquals(true, extractor.getExtended());
+        assertEquals(true, extractor.getUpright());
+        assertEquals(0.125, extractor.getThreshold());
+        assertEquals(3, extractor.getNOctaves());
+        assertEquals(5, extractor.getNOctaveLayers());
+        assertEquals(2, extractor.getDiffusivity());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nformat: 3\nname: \"Feature2D.KAZE\"\nextended: 0\nupright: 0\nthreshold: 0.0010000000474974513\noctaves: 4\nsublevels: 4\ndiffusivity: 1\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/MSERFeatureDetectorTest.java

@@ -0,0 +1,70 @@
+package org.opencv.test.features2d;
+
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.features2d.MSER;
+
+public class MSERFeatureDetectorTest extends OpenCVTestCase {
+
+    MSER detector;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = MSER.create(); // default constructor have (5, 60, 14400, .25, .2, 200, 1.01, .003, 5)
+    }
+
+    public void testCreate() {
+        assertNotNull(detector);
+    }
+
+    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 testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.MSER\"\ndelta: 6\nminArea: 62\nmaxArea: 14402\nmaxVariation: .26\nminDiversity: .3\nmaxEvolution: 201\nareaThreshold: 1.02\nminMargin: 3.0e-3\nedgeBlurSize: 3\npass2Only: 1\n");
+        detector.read(filename);
+
+        assertEquals(6, detector.getDelta());
+        assertEquals(62, detector.getMinArea());
+        assertEquals(14402, detector.getMaxArea());
+        assertEquals(.26, detector.getMaxVariation());
+        assertEquals(.3, detector.getMinDiversity());
+        assertEquals(201, detector.getMaxEvolution());
+        assertEquals(1.02, detector.getAreaThreshold());
+        assertEquals(0.003, detector.getMinMargin());
+        assertEquals(3, detector.getEdgeBlurSize());
+        assertEquals(true, detector.getPass2Only());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        detector.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.MSER\"\ndelta: 5\nminArea: 60\nmaxArea: 14400\nmaxVariation: 0.25\nminDiversity: 0.20000000000000001\nmaxEvolution: 200\nareaThreshold: 1.01\nminMargin: 0.0030000000000000001\nedgeBlurSize: 5\npass2Only: 0\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/ORBDescriptorExtractorTest.java

@@ -0,0 +1,121 @@
+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.core.KeyPoint;
+import org.opencv.features2d.ORB;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+
+public class ORBDescriptorExtractorTest extends OpenCVTestCase {
+
+    ORB 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 = ORB.create();
+        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, 44, 132, 66, 165, 172, 6, 3, 72, 102, 61, 171, 214, 0, 144, 65, 232, 4, 32, 138, 131, 4, 21, 37, 217);
+            }
+        };
+        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());
+        fail("Not yet implemented"); // ORB does not override empty() method
+    }
+
+    public void testReadYml() {
+        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\n---\nnfeatures: 500\nscaleFactor: 1.1\nnlevels: 3\nedgeThreshold: 31\nfirstLevel: 0\nwta_k: 2\nscoreType: 0\npatchSize: 31\nfastThreshold: 20\n");
+        extractor.read(filename);
+
+        assertEquals(500, extractor.getMaxFeatures());
+        assertEquals(1.1, extractor.getScaleFactor());
+        assertEquals(3, extractor.getNLevels());
+        assertEquals(31, extractor.getEdgeThreshold());
+        assertEquals(0, extractor.getFirstLevel());
+        assertEquals(2, extractor.getWTA_K());
+        assertEquals(0, extractor.getScoreType());
+        assertEquals(31, extractor.getPatchSize());
+        assertEquals(20, extractor.getFastThreshold());
+
+        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, 74, 131, 0, 37, 37, 67);
+            }
+        };
+        assertDescriptorsClose(truth, descriptors, 1);
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.ORB\"\nnfeatures: 500\nscaleFactor: 1.2000000476837158\nnlevels: 8\nedgeThreshold: 31\nfirstLevel: 0\nwta_k: 2\nscoreType: 0\npatchSize: 31\nfastThreshold: 20\n";
+//        String truth = "%YAML:1.0\n---\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,78 @@
+package org.opencv.test.features2d;
+
+import org.junit.Assert;
+import org.opencv.core.CvType;
+import org.opencv.core.KeyPoint;
+import org.opencv.core.Mat;
+import org.opencv.core.MatOfKeyPoint;
+import org.opencv.core.Scalar;
+import org.opencv.features2d.Features2d;
+import org.opencv.features2d.ORB;
+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");
+    }
+
+    public void testDetectTwoPoints() {
+        Mat img = new Mat(256,256, CvType.CV_8UC3, new Scalar(0,0,0));
+        img.put(35, 40, 255,255, 255);
+        img.put(152, 98, 200,0, 0);
+
+        MatOfKeyPoint keypoints = new MatOfKeyPoint();
+        ORB orb = ORB.create();
+        Mat descriptors = new Mat();
+        orb.detectAndCompute(img, new Mat(), keypoints, descriptors);
+
+        KeyPoint[] keypointsArray = keypoints.toArray();
+        assertEquals(2, keypointsArray.length);
+
+        long x1 = Math.round(keypointsArray[0].pt.x);
+        long y1 = Math.round(keypointsArray[0].pt.y);
+        long x2 = Math.round(keypointsArray[1].pt.x);
+        long y2 = Math.round(keypointsArray[1].pt.y);
+
+        if (x2 > x1) {
+            assertEquals(40, x1);
+            assertEquals(35, y1);
+            assertEquals(98, x2);
+            assertEquals(152, y2);
+        } else {
+            assertEquals(40, x2);
+            assertEquals(35, y2);
+            assertEquals(98, x1);
+            assertEquals(152, y1);
+        }
+    }
+
+}

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

@@ -0,0 +1,109 @@
+package org.opencv.test.features2d;
+
+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.core.KeyPoint;
+import org.opencv.features2d.SIFT;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.SIFT;
+
+public class SIFTDescriptorExtractorTest extends OpenCVTestCase {
+
+    SIFT 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 = SIFT.create();
+        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());
+        fail("Not yet implemented"); // SIFT does not override empty() method
+    }
+
+    public void testReadYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\n---\nname: \"Feature2D.SIFT\"\nnfeatures: 100\nnOctaveLayers: 4\ncontrastThreshold: 5.0000000000000001e-02\nedgeThreshold: 11\nsigma: 1.7\ndescriptorType: 5\n");
+
+        extractor.read(filename);
+
+        assertEquals(128, extractor.descriptorSize());
+
+        assertEquals(100, extractor.getNFeatures());
+        assertEquals(4, extractor.getNOctaveLayers());
+        assertEquals(0.05, extractor.getContrastThreshold());
+        assertEquals(11., extractor.getEdgeThreshold());
+        assertEquals(1.7, extractor.getSigma());
+        assertEquals(5, extractor.descriptorType());
+    }
+
+    public void testWriteYml() {
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+
+        extractor.write(filename);
+
+        String truth = "%YAML:1.0\n---\nname: \"Feature2D.SIFT\"\nnfeatures: 0\nnOctaveLayers: 3\ncontrastThreshold: 0.040000000000000001\nedgeThreshold: 10.\nsigma: 1.6000000000000001\ndescriptorType: 5\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,138 @@
+package org.opencv.test.features2d;
+
+import java.util.Arrays;
+
+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.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+import org.opencv.test.OpenCVTestRunner;
+import org.opencv.imgproc.Imgproc;
+import org.opencv.features2d.SimpleBlobDetector;
+import org.opencv.features2d.SimpleBlobDetector_Params;
+
+public class SIMPLEBLOBFeatureDetectorTest extends OpenCVTestCase {
+
+    SimpleBlobDetector 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() {
+
+        int center = matSize / 2;
+        int offset = 40;
+
+        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
+        Imgproc.circle(img, new Point(center - offset, center), 24, new Scalar(0), -1);
+        Imgproc.circle(img, new Point(center + offset, center), 20, new Scalar(50), -1);
+        Imgproc.circle(img, new Point(center, center - offset), 18, new Scalar(100), -1);
+        Imgproc.circle(img, new Point(center, center + offset), 14, new Scalar(150), -1);
+        Imgproc.circle(img, new Point(center, center), 10, new Scalar(200), -1);
+        return img;
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        detector = SimpleBlobDetector.create();
+        matSize = 200;
+        truth = new KeyPoint[] {
+                new KeyPoint(140, 100, 41.036568f, -1, 0, 0, -1),
+                new KeyPoint(60, 100, 48.538486f, -1, 0, 0, -1),
+                new KeyPoint(100, 60, 36.769554f, -1, 0, 0, -1),
+                new KeyPoint(100, 140, 28.635643f, -1, 0, 0, -1),
+                new KeyPoint(100, 100, 20.880613f, -1, 0, 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[1]), keypoints.toList(), EPS);
+    }
+
+    public void testEmpty() {
+//        assertFalse(detector.empty());
+        fail("Not yet implemented");
+    }
+
+    public void testReadYml() {
+        Mat img = getTestImg();
+
+        MatOfKeyPoint keypoints1 = new MatOfKeyPoint();
+        detector.detect(img, keypoints1);
+
+        String filename = OpenCVTestRunner.getTempFileName("yml");
+        writeFile(filename, "%YAML:1.0\nthresholdStep: 10.0\nminThreshold: 50\nmaxThreshold: 220\nminRepeatability: 2\nminDistBetweenBlobs: 10.\nfilterByColor: 1\nblobColor: 0\nfilterByArea: 1\nminArea: 800\nmaxArea: 6000\nfilterByCircularity: 0\nminCircularity: 0.7\nmaxCircularity: 10.\nfilterByInertia: 1\nminInertiaRatio: 0.2\nmaxInertiaRatio: 11.\nfilterByConvexity: true\nminConvexity: 0.9\nmaxConvexity: 12.\n");
+        detector.read(filename);
+
+        SimpleBlobDetector_Params params = detector.getParams();
+        assertEquals(10.0f, params.get_thresholdStep());
+        assertEquals(50f, params.get_minThreshold());
+        assertEquals(220f, params.get_maxThreshold());
+        assertEquals(2, params.get_minRepeatability());
+        assertEquals(10.0f, params.get_minDistBetweenBlobs());
+        assertEquals(true, params.get_filterByColor());
+        assertEquals(0, params.get_blobColor());
+        assertEquals(true, params.get_filterByArea());
+        assertEquals(800f, params.get_minArea());
+        assertEquals(6000f, params.get_maxArea());
+        assertEquals(false, params.get_filterByCircularity());
+        assertEquals(0.7f, params.get_minCircularity());
+        assertEquals(10.0f, params.get_maxCircularity());
+        assertEquals(true, params.get_filterByInertia());
+        assertEquals(0.2f, params.get_minInertiaRatio());
+        assertEquals(11.0f, params.get_maxInertiaRatio());
+        assertEquals(true, params.get_filterByConvexity());
+        assertEquals(0.9f, params.get_minConvexity());
+        assertEquals(12.0f, params.get_maxConvexity());
+
+        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<format>3</format>\n<thresholdStep>10.</thresholdStep>\n<minThreshold>50.</minThreshold>\n<maxThreshold>220.</maxThreshold>\n<minRepeatability>2</minRepeatability>\n<minDistBetweenBlobs>10.</minDistBetweenBlobs>\n<filterByColor>1</filterByColor>\n<blobColor>0</blobColor>\n<filterByArea>1</filterByArea>\n<minArea>25.</minArea>\n<maxArea>5000.</maxArea>\n<filterByCircularity>0</filterByCircularity>\n<minCircularity>0.80000001192092896</minCircularity>\n<maxCircularity>3.4028234663852886e+38</maxCircularity>\n<filterByInertia>1</filterByInertia>\n<minInertiaRatio>0.10000000149011612</minInertiaRatio>\n<maxInertiaRatio>3.4028234663852886e+38</maxInertiaRatio>\n<filterByConvexity>1</filterByConvexity>\n<minConvexity>0.94999998807907104</minConvexity>\n<maxConvexity>3.4028234663852886e+38</maxConvexity>\n<collectContours>0</collectContours>\n</opencv_storage>\n";
+        assertEquals(truth, readFile(filename));
+    }
+}