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

   1 package org.opencv.test.features2d;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.List;
   6
   7 import org.opencv.core.Core;
   8 import org.opencv.core.CvType;
   9 import org.opencv.core.Mat;
  10 import org.opencv.core.MatOfDMatch;
  11 import org.opencv.core.MatOfKeyPoint;
  12 import org.opencv.core.Point;
  13 import org.opencv.core.Scalar;
  14 import org.opencv.core.DMatch;
  15 import org.opencv.features2d.DescriptorExtractor;
  16 import org.opencv.features2d.DescriptorMatcher;
  17 import org.opencv.features2d.FeatureDetector;
  18 import org.opencv.core.KeyPoint;
  19 import org.opencv.test.OpenCVTestCase;
  20 import org.opencv.test.OpenCVTestRunner;
  21
  22 public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
  23
  24     DescriptorMatcher matcher;
  25     int matSize;
  26     DMatch[] truth;
  27
  28     private Mat getMaskImg() {
  29         return new Mat(5, 2, CvType.CV_8U, new Scalar(0)) {
  30             {
  31                 put(0, 0, 1, 1, 1, 1);
  32             }
  33         };
  34     }
  35
  36     private Mat getQueryDescriptors() {
  37         Mat img = getQueryImg();
  38         MatOfKeyPoint keypoints = new MatOfKeyPoint();
  39         Mat descriptors = new Mat();
  40
  41         FeatureDetector detector = FeatureDetector.create(FeatureDetector.SURF);
  42         DescriptorExtractor extractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
  43
  44         String filename = OpenCVTestRunner.getTempFileName("yml");
  45         writeFile(filename, "%YAML:1.0\nhessianThreshold: 8000.\noctaves: 3\noctaveLayers: 4\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);
  85         matSize = 100;
  86
  87         truth = new DMatch[] {
  88                 new DMatch(0, 0, 0, 0.6211397f),
  89                 new DMatch(1, 1, 0, 0.9177120f),
  90                 new DMatch(2, 1, 0, 0.3112163f),
  91                 new DMatch(3, 1, 0, 0.2925074f),
  92                 new DMatch(4, 1, 0, 0.9309178f)
  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         final int k = 3;
 169         Mat train = getTrainDescriptors();
 170         Mat query = getQueryDescriptors();
 171         List<MatOfDMatch> matches = new ArrayList<MatOfDMatch>();
 172         matcher.knnMatch(query, train, matches, k);
 173         /*
 174         Log.d("knnMatch", "train = " + train);
 175         Log.d("knnMatch", "query = " + query);
 176
 177         matcher.add(train);
 178         matcher.knnMatch(query, matches, k);
 179         */
 180         assertEquals(query.rows(), matches.size());
 181         for(int i = 0; i<matches.size(); i++)
 182         {
 183             MatOfDMatch vdm = matches.get(i);
 184             //Log.d("knn", "vdm["+i+"]="+vdm.dump());
 185             assertTrue(Math.min(k, train.rows()) >= vdm.total());
 186             for(DMatch dm : vdm.toArray())
 187             {
 188                 assertEquals(dm.queryIdx, i);
 189             }
 190         }
 191     }
 192
 193     public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
 194         fail("Not yet implemented");
 195     }
 196
 197     public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
 198         fail("Not yet implemented");
 199     }
 200
 201     public void testMatchMatListOfDMatch() {
 202         Mat train = getTrainDescriptors();
 203         Mat query = getQueryDescriptors();
 204         MatOfDMatch matches = new MatOfDMatch();
 205         matcher.add(Arrays.asList(train));
 206
 207         matcher.match(query, matches);
 208
 209         assertArrayDMatchEquals(truth, matches.toArray(), EPS);
 210     }
 211
 212     public void testMatchMatListOfDMatchListOfMat() {
 213         Mat train = getTrainDescriptors();
 214         Mat query = getQueryDescriptors();
 215         Mat mask = getMaskImg();
 216         MatOfDMatch matches = new MatOfDMatch();
 217         matcher.add(Arrays.asList(train));
 218
 219         matcher.match(query, matches, Arrays.asList(mask));
 220
 221         assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
 222     }
 223
 224     public void testMatchMatMatListOfDMatch() {
 225         Mat train = getTrainDescriptors();
 226         Mat query = getQueryDescriptors();
 227         MatOfDMatch matches = new MatOfDMatch();
 228
 229         matcher.match(query, train, matches);
 230
 231         assertArrayDMatchEquals(truth, matches.toArray(), EPS);
 232
 233         // OpenCVTestRunner.Log("matches found: " + matches.size());
 234         // for (DMatch m : matches)
 235         // OpenCVTestRunner.Log(m.toString());
 236     }
 237
 238     public void testMatchMatMatListOfDMatchMat() {
 239         Mat train = getTrainDescriptors();
 240         Mat query = getQueryDescriptors();
 241         Mat mask = getMaskImg();
 242         MatOfDMatch matches = new MatOfDMatch();
 243
 244         matcher.match(query, train, matches, mask);
 245
 246         assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
 247     }
 248
 249     public void testRadiusMatchMatListOfListOfDMatchFloat() {
 250         fail("Not yet implemented");
 251     }
 252
 253     public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
 254         fail("Not yet implemented");
 255     }
 256
 257     public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
 258         fail("Not yet implemented");
 259     }
 260
 261     public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
 262         fail("Not yet implemented");
 263     }
 264
 265     public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
 266         fail("Not yet implemented");
 267     }
 268
 269     public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
 270         fail("Not yet implemented");
 271     }
 272
 273     public void testRead() {
 274         String filename = OpenCVTestRunner.getTempFileName("yml");
 275         writeFile(filename, "%YAML:1.0\n");
 276
 277         matcher.read(filename);
 278         assertTrue(true);// BruteforceMatcher has no settings
 279     }
 280
 281     public void testTrain() {
 282         matcher.train();// BruteforceMatcher does not need to train
 283     }
 284
 285     public void testWrite() {
 286         String filename = OpenCVTestRunner.getTempFileName("yml");
 287
 288         matcher.write(filename);
 289
 290         String truth = "%YAML:1.0\n";
 291         assertEquals(truth, readFile(filename));
 292     }
 293
 294 }