modules/java/android_test/src/org/opencv/test/features2d/BruteForceL1DescriptorMatcherTest.java

   1 package org.opencv.test.features2d;
   2
   3 import java.util.Arrays;
   4 import java.util.List;
   5
   6 import org.opencv.core.Core;
   7 import org.opencv.core.CvType;
   8 import org.opencv.core.Mat;
   9 import org.opencv.core.MatOfDMatch;
  10 import org.opencv.core.MatOfKeyPoint;
  11 import org.opencv.core.Point;
  12 import org.opencv.core.Scalar;
  13 import org.opencv.core.DMatch;
  14 import org.opencv.features2d.DescriptorExtractor;
  15 import org.opencv.features2d.DescriptorMatcher;
  16 import org.opencv.features2d.FeatureDetector;
  17 import org.opencv.core.KeyPoint;
  18 import org.opencv.test.OpenCVTestCase;
  19 import org.opencv.test.OpenCVTestRunner;
  20
  21 public class BruteForceL1DescriptorMatcherTest extends OpenCVTestCase {
  22
  23     DescriptorMatcher matcher;
  24     int matSize;
  25     DMatch[] truth;
  26
  27     private Mat getMaskImg() {
  28         return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
  29             {
  30                 put(0, 0, 1, 1, 1, 1);
  31             }
  32         };
  33     }
  34
  35     private Mat getQueryDescriptors() {
  36         Mat img = getQueryImg();
  37         MatOfKeyPoint keypoints = new MatOfKeyPoint();
  38         Mat descriptors = new Mat();
  39
  40         FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
  41         DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
  42
  43         String filename = OpenCVTestRunner.getTempFileName("yml");
  44         //writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\nupright: 0\n");
  45         writeFile(filename, "%YAML:1.0\nname: \"Feature2D.SURF\"\nextended: 1\nhessianThreshold: 8000.\nnOctaveLayers: 2\nnOctaves: 3\nupright: 0\n");
  46         detector.read(filename);
  47
  48         detector.detect(img, keypoints);
  49         extractor.compute(img, keypoints, descriptors);
  50
  51         return descriptors;
  52     }
  53
  54     private Mat getQueryImg() {
  55         Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
  56         Core.line(cross, new Point(30, matSize / 2), new Point(matSize - 31, matSize / 2), new Scalar(100), 3);
  57         Core.line(cross, new Point(matSize / 2, 30), new Point(matSize / 2, matSize - 31), new Scalar(100), 3);
  58
  59         return cross;
  60     }
  61
  62     private Mat getTrainDescriptors() {
  63         Mat img = getTrainImg();
  64         MatOfKeyPoint keypoints = new MatOfKeyPoint(new KeyPoint(50, 50, 16, 0, 20000, 1, -1), new KeyPoint(42, 42, 16, 160, 10000, 1, -1));
  65         Mat descriptors = new Mat();
  66
  67         DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
  68
  69         extractor.compute(img, keypoints, descriptors);
  70
  71         return descriptors;
  72     }
  73
  74     private Mat getTrainImg() {
  75         Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
  76         Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
  77         Core.line(cross, new Point(matSize / 2, 20), new Point(matSize / 2, matSize - 21), new Scalar(100), 2);
  78
  79         return cross;
  80     }
  81
  82     protected void setUp() throws Exception {
  83         super.setUp();
  84         matcher = DescriptorMatcher.create(DescriptorMatcher.BRUTEFORCE_L1);
  85         matSize = 100;
  86
  87         truth = new DMatch[] {
  88                 new DMatch(0, 0, 0, 3.0975165f),
  89                 new DMatch(1, 1, 0, 3.5680308f),
  90                 new DMatch(2, 1, 0, 1.3722466f),
  91                 new DMatch(3, 1, 0, 1.3041023f),
  92                 new DMatch(4, 1, 0, 3.5970376f)
  93                 };
  94     }
  95
  96     public void testAdd() {
  97         matcher.add(Arrays.asList(new Mat()));
  98         assertFalse(matcher.empty());
  99     }
 100
 101     public void testClear() {
 102         matcher.add(Arrays.asList(new Mat()));
 103
 104         matcher.clear();
 105
 106         assertTrue(matcher.empty());
 107     }
 108
 109     public void testClone() {
 110         Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
 111         Mat truth = train.clone();
 112         matcher.add(Arrays.asList(train));
 113
 114         DescriptorMatcher cloned = matcher.clone();
 115
 116         assertNotNull(cloned);
 117
 118         List<Mat> descriptors = cloned.getTrainDescriptors();
 119         assertEquals(1, descriptors.size());
 120         assertMatEqual(truth, descriptors.get(0));
 121     }
 122
 123     public void testCloneBoolean() {
 124         matcher.add(Arrays.asList(new Mat()));
 125
 126         DescriptorMatcher cloned = matcher.clone(true);
 127
 128         assertNotNull(cloned);
 129         assertTrue(cloned.empty());
 130     }
 131
 132     public void testCreate() {
 133         assertNotNull(matcher);
 134     }
 135
 136     public void testEmpty() {
 137         assertTrue(matcher.empty());
 138     }
 139
 140     public void testGetTrainDescriptors() {
 141         Mat train = new Mat(1, 1, CvType.CV_8U, new Scalar(123));
 142         Mat truth = train.clone();
 143         matcher.add(Arrays.asList(train));
 144
 145         List<Mat> descriptors = matcher.getTrainDescriptors();
 146
 147         assertEquals(1, descriptors.size());
 148         assertMatEqual(truth, descriptors.get(0));
 149     }
 150
 151     public void testIsMaskSupported() {
 152         assertTrue(matcher.isMaskSupported());
 153     }
 154
 155     public void testKnnMatchMatListOfListOfDMatchInt() {
 156         fail("Not yet implemented");
 157     }
 158
 159     public void testKnnMatchMatListOfListOfDMatchIntListOfMat() {
 160         fail("Not yet implemented");
 161     }
 162
 163     public void testKnnMatchMatListOfListOfDMatchIntListOfMatBoolean() {
 164         fail("Not yet implemented");
 165     }
 166
 167     public void testKnnMatchMatMatListOfListOfDMatchInt() {
 168         fail("Not yet implemented");
 169     }
 170
 171     public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
 172         fail("Not yet implemented");
 173     }
 174
 175     public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
 176         fail("Not yet implemented");
 177     }
 178
 179     public void testMatchMatListOfDMatch() {
 180         Mat train = getTrainDescriptors();
 181         Mat query = getQueryDescriptors();
 182         MatOfDMatch matches = new MatOfDMatch();
 183         matcher.add(Arrays.asList(train));
 184
 185         matcher.match(query, matches);
 186
 187         assertArrayDMatchEquals(truth, matches.toArray(), EPS);
 188     }
 189
 190     public void testMatchMatListOfDMatchListOfMat() {
 191         Mat train = getTrainDescriptors();
 192         Mat query = getQueryDescriptors();
 193         Mat mask = getMaskImg();
 194         MatOfDMatch matches = new MatOfDMatch();
 195         matcher.add(Arrays.asList(train));
 196
 197         matcher.match(query, matches, Arrays.asList(mask));
 198
 199         assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
 200     }
 201
 202     public void testMatchMatMatListOfDMatch() {
 203         Mat train = getTrainDescriptors();
 204         Mat query = getQueryDescriptors();
 205         MatOfDMatch matches = new MatOfDMatch();
 206
 207         matcher.match(query, train, matches);
 208
 209         assertArrayDMatchEquals(truth, matches.toArray(), EPS);
 210     }
 211
 212     public void testMatchMatMatListOfDMatchMat() {
 213         Mat train = getTrainDescriptors();
 214         Mat query = getQueryDescriptors();
 215         Mat mask = getMaskImg();
 216         MatOfDMatch matches = new MatOfDMatch();
 217
 218         matcher.match(query, train, matches, mask);
 219
 220         assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
 221     }
 222
 223     public void testRadiusMatchMatListOfListOfDMatchFloat() {
 224         fail("Not yet implemented");
 225     }
 226
 227     public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
 228         fail("Not yet implemented");
 229     }
 230
 231     public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
 232         fail("Not yet implemented");
 233     }
 234
 235     public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
 236         fail("Not yet implemented");
 237     }
 238
 239     public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
 240         fail("Not yet implemented");
 241     }
 242
 243     public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
 244         fail("Not yet implemented");
 245     }
 246
 247     public void testRead() {
 248         String filename = OpenCVTestRunner.getTempFileName("yml");
 249         writeFile(filename, "%YAML:1.0\n");
 250
 251         matcher.read(filename);
 252         assertTrue(true);// BruteforceMatcher has no settings
 253     }
 254
 255     public void testTrain() {
 256         matcher.train();// BruteforceMatcher does not need to train
 257     }
 258
 259     public void testWrite() {
 260         String filename = OpenCVTestRunner.getTempFileName("yml");
 261
 262         matcher.write(filename);
 263
 264         String truth = "%YAML:1.0\n";
 265         assertEquals(truth, readFile(filename));
 266     }
 267
 268 }