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