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 import org.opencv.imgproc.Imgproc;
21 
22 public class BruteForceL1DescriptorMatcherTest extends OpenCVTestCase {
23 
24     DescriptorMatcher matcher;
25     int matSize;
26     DMatch[] truth;
27 
getMaskImg()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         writeFile(filename, "%YAML:1.0\nname: \"Feature2D.SURF\"\nextended: 1\nhessianThreshold: 8000.\nnOctaveLayers: 2\nnOctaves: 3\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_L1);
86         matSize = 100;
87 
88         truth = new DMatch[] {
89                 new DMatch(0, 0, 0, 3.0975165f),
90                 new DMatch(1, 1, 0, 3.5680308f),
91                 new DMatch(2, 1, 0, 1.3722466f),
92                 new DMatch(3, 1, 0, 1.3041023f),
93                 new DMatch(4, 1, 0, 3.5970376f)
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         fail("Not yet implemented");
170     }
171 
172     public void testKnnMatchMatMatListOfListOfDMatchIntMat() {
173         fail("Not yet implemented");
174     }
175 
176     public void testKnnMatchMatMatListOfListOfDMatchIntMatBoolean() {
177         fail("Not yet implemented");
178     }
179 
180     public void testMatchMatListOfDMatch() {
181         Mat train = getTrainDescriptors();
182         Mat query = getQueryDescriptors();
183         MatOfDMatch matches = new MatOfDMatch();
184         matcher.add(Arrays.asList(train));
185 
186         matcher.match(query, matches);
187 
188         assertArrayDMatchEquals(truth, matches.toArray(), EPS);
189     }
190 
191     public void testMatchMatListOfDMatchListOfMat() {
192         Mat train = getTrainDescriptors();
193         Mat query = getQueryDescriptors();
194         Mat mask = getMaskImg();
195         MatOfDMatch matches = new MatOfDMatch();
196         matcher.add(Arrays.asList(train));
197 
198         matcher.match(query, matches, Arrays.asList(mask));
199 
200         assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
201     }
202 
203     public void testMatchMatMatListOfDMatch() {
204         Mat train = getTrainDescriptors();
205         Mat query = getQueryDescriptors();
206         MatOfDMatch matches = new MatOfDMatch();
207 
208         matcher.match(query, train, matches);
209 
210         assertArrayDMatchEquals(truth, matches.toArray(), EPS);
211     }
212 
213     public void testMatchMatMatListOfDMatchMat() {
214         Mat train = getTrainDescriptors();
215         Mat query = getQueryDescriptors();
216         Mat mask = getMaskImg();
217         MatOfDMatch matches = new MatOfDMatch();
218 
219         matcher.match(query, train, matches, mask);
220 
221         assertListDMatchEquals(Arrays.asList(truth[0], truth[1]), matches.toList(), EPS);
222     }
223 
224     public void testRadiusMatchMatListOfListOfDMatchFloat() {
225         fail("Not yet implemented");
226     }
227 
228     public void testRadiusMatchMatListOfListOfDMatchFloatListOfMat() {
229         fail("Not yet implemented");
230     }
231 
232     public void testRadiusMatchMatListOfListOfDMatchFloatListOfMatBoolean() {
233         fail("Not yet implemented");
234     }
235 
236     public void testRadiusMatchMatMatListOfListOfDMatchFloat() {
237         fail("Not yet implemented");
238     }
239 
240     public void testRadiusMatchMatMatListOfListOfDMatchFloatMat() {
241         fail("Not yet implemented");
242     }
243 
244     public void testRadiusMatchMatMatListOfListOfDMatchFloatMatBoolean() {
245         fail("Not yet implemented");
246     }
247 
248     public void testRead() {
249         String filename = OpenCVTestRunner.getTempFileName("yml");
250         writeFile(filename, "%YAML:1.0\n");
251 
252         matcher.read(filename);
253         assertTrue(true);// BruteforceMatcher has no settings
254     }
255 
256     public void testTrain() {
257         matcher.train();// BruteforceMatcher does not need to train
258     }
259 
260     public void testWrite() {
261         String filename = OpenCVTestRunner.getTempFileName("yml");
262 
263         matcher.write(filename);
264 
265         String truth = "%YAML:1.0\n";
266         assertEquals(truth, readFile(filename));
267     }
268 
269 }
270