← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/modules/imgproc/misc/java/test/ImgprocTest.java

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/modules/imgproc/misc/java/test/ImgprocTest.java
 
1
package org.opencv.test.imgproc;
 
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.MatOfFloat;
 
11
import org.opencv.core.MatOfInt;
 
12
import org.opencv.core.MatOfInt4;
 
13
import org.opencv.core.MatOfPoint;
 
14
import org.opencv.core.MatOfPoint2f;
 
15
import org.opencv.core.Point;
 
16
import org.opencv.core.Rect;
 
17
import org.opencv.core.RotatedRect;
 
18
import org.opencv.core.Scalar;
 
19
import org.opencv.core.Size;
 
20
import org.opencv.core.TermCriteria;
 
21
import org.opencv.imgproc.Imgproc;
 
22
import org.opencv.test.OpenCVTestCase;
 
23
 
 
24
public class ImgprocTest extends OpenCVTestCase {
 
25
 
 
26
    Point anchorPoint;
 
27
    private int imgprocSz;
 
28
    Size size;
 
29
 
 
30
    @Override
 
31
    protected void setUp() throws Exception {
 
32
        super.setUp();
 
33
 
 
34
        imgprocSz = 2;
 
35
        anchorPoint = new Point(2, 2);
 
36
        size = new Size(3, 3);
 
37
    }
 
38
 
 
39
    public void testAccumulateMatMat() {
 
40
        Mat src = getMat(CvType.CV_64F, 2);
 
41
        Mat dst = getMat(CvType.CV_64F, 0);
 
42
        Mat dst2 = src.clone();
 
43
 
 
44
        Imgproc.accumulate(src, dst);
 
45
        Imgproc.accumulate(src, dst2);
 
46
 
 
47
        assertMatEqual(src, dst, EPS);
 
48
        assertMatEqual(getMat(CvType.CV_64F, 4), dst2, EPS);
 
49
    }
 
50
 
 
51
    public void testAccumulateMatMatMat() {
 
52
        Mat src = getMat(CvType.CV_64F, 2);
 
53
        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
 
54
        Mat dst = getMat(CvType.CV_64F, 0);
 
55
        Mat dst2 = src.clone();
 
56
 
 
57
        Imgproc.accumulate(src, dst, mask);
 
58
        Imgproc.accumulate(src, dst2, mask);
 
59
 
 
60
        assertMatEqual(makeMask(getMat(CvType.CV_64F, 2)), dst, EPS);
 
61
        assertMatEqual(makeMask(getMat(CvType.CV_64F, 4), 2), dst2, EPS);
 
62
    }
 
63
 
 
64
    public void testAccumulateProductMatMatMat() {
 
65
        Mat src = getMat(CvType.CV_64F, 2);
 
66
        Mat dst = getMat(CvType.CV_64F, 0);
 
67
        Mat dst2 = src.clone();
 
68
 
 
69
        Imgproc.accumulateProduct(src, src, dst);
 
70
        Imgproc.accumulateProduct(src, dst, dst2);
 
71
 
 
72
        assertMatEqual(getMat(CvType.CV_64F, 4), dst, EPS);
 
73
        assertMatEqual(getMat(CvType.CV_64F, 10), dst2, EPS);
 
74
    }
 
75
 
 
76
    public void testAccumulateProductMatMatMatMat() {
 
77
        Mat src = getMat(CvType.CV_64F, 2);
 
78
        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
 
79
        Mat dst = getMat(CvType.CV_64F, 0);
 
80
        Mat dst2 = src.clone();
 
81
 
 
82
        Imgproc.accumulateProduct(src, src, dst, mask);
 
83
        Imgproc.accumulateProduct(src, dst, dst2, mask);
 
84
 
 
85
        assertMatEqual(makeMask(getMat(CvType.CV_64F, 4)), dst, EPS);
 
86
        assertMatEqual(makeMask(getMat(CvType.CV_64F, 10), 2), dst2, EPS);
 
87
    }
 
88
 
 
89
    public void testAccumulateSquareMatMat() {
 
90
        Mat src = getMat(CvType.CV_64F, 2);
 
91
        Mat dst = getMat(CvType.CV_64F, 0);
 
92
        Mat dst2 = src.clone();
 
93
 
 
94
        Imgproc.accumulateSquare(src, dst);
 
95
        Imgproc.accumulateSquare(src, dst2);
 
96
 
 
97
        assertMatEqual(getMat(CvType.CV_64F, 4), dst, EPS);
 
98
        assertMatEqual(getMat(CvType.CV_64F, 6), dst2, EPS);
 
99
    }
 
100
 
 
101
    public void testAccumulateSquareMatMatMat() {
 
102
        Mat src = getMat(CvType.CV_64F, 2);
 
103
        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
 
104
        Mat dst = getMat(CvType.CV_64F, 0);
 
105
        Mat dst2 = src.clone();
 
106
 
 
107
        Imgproc.accumulateSquare(src, dst, mask);
 
108
        Imgproc.accumulateSquare(src, dst2, mask);
 
109
 
 
110
        assertMatEqual(makeMask(getMat(CvType.CV_64F, 4)), dst, EPS);
 
111
        assertMatEqual(makeMask(getMat(CvType.CV_64F, 6), 2), dst2, EPS);
 
112
    }
 
113
 
 
114
    public void testAccumulateWeightedMatMatDouble() {
 
115
        Mat src = getMat(CvType.CV_64F, 2);
 
116
        Mat dst = getMat(CvType.CV_64F, 4);
 
117
        Mat dst2 = src.clone();
 
118
 
 
119
        Imgproc.accumulateWeighted(src, dst, 0.5);
 
120
        Imgproc.accumulateWeighted(src, dst2, 2);
 
121
 
 
122
        assertMatEqual(getMat(CvType.CV_64F, 3), dst, EPS);
 
123
        assertMatEqual(getMat(CvType.CV_64F, 2), dst2, EPS);
 
124
    }
 
125
 
 
126
    public void testAccumulateWeightedMatMatDoubleMat() {
 
127
        Mat src = getMat(CvType.CV_64F, 2);
 
128
        Mat mask = makeMask(getMat(CvType.CV_8U, 1));
 
129
        Mat dst = getMat(CvType.CV_64F, 4);
 
130
        Mat dst2 = src.clone();
 
131
 
 
132
        Imgproc.accumulateWeighted(src, dst, 0.5, mask);
 
133
        Imgproc.accumulateWeighted(src, dst2, 2, mask);
 
134
 
 
135
        assertMatEqual(makeMask(getMat(CvType.CV_64F, 3), 4), dst, EPS);
 
136
        assertMatEqual(getMat(CvType.CV_64F, 2), dst2, EPS);
 
137
    }
 
138
 
 
139
    public void testAdaptiveThreshold() {
 
140
        Mat src = makeMask(getMat(CvType.CV_8U, 50), 20);
 
141
        Mat dst = new Mat();
 
142
 
 
143
        Imgproc.adaptiveThreshold(src, dst, 1, Imgproc.ADAPTIVE_THRESH_MEAN_C, Imgproc.THRESH_BINARY, 3, 0);
 
144
 
 
145
        assertEquals(src.rows(), Core.countNonZero(dst));
 
146
    }
 
147
 
 
148
    public void testApproxPolyDP() {
 
149
        MatOfPoint2f curve = new MatOfPoint2f(new Point(1, 3), new Point(2, 4), new Point(3, 5), new Point(4, 4), new Point(5, 3));
 
150
 
 
151
        MatOfPoint2f approxCurve = new MatOfPoint2f();
 
152
 
 
153
        Imgproc.approxPolyDP(curve, approxCurve, EPS, true);
 
154
 
 
155
        List<Point> approxCurveGold =  new ArrayList<Point>(3);
 
156
        approxCurveGold.add(new Point(1, 3));
 
157
        approxCurveGold.add(new Point(3, 5));
 
158
        approxCurveGold.add(new Point(5, 3));
 
159
 
 
160
        assertListPointEquals(approxCurve.toList(), approxCurveGold, EPS);
 
161
    }
 
162
 
 
163
    public void testArcLength() {
 
164
        MatOfPoint2f curve = new MatOfPoint2f(new Point(1, 3), new Point(2, 4), new Point(3, 5), new Point(4, 4), new Point(5, 3));
 
165
 
 
166
        double arcLength = Imgproc.arcLength(curve, false);
 
167
 
 
168
        assertEquals(5.656854249, arcLength, 0.000001);
 
169
    }
 
170
 
 
171
    public void testBilateralFilterMatMatIntDoubleDouble() {
 
172
        Imgproc.bilateralFilter(gray255, dst, 5, 10, 5);
 
173
 
 
174
        assertMatEqual(gray255, dst);
 
175
        // TODO_: write better test
 
176
    }
 
177
 
 
178
    public void testBilateralFilterMatMatIntDoubleDoubleInt() {
 
179
        Imgproc.bilateralFilter(gray255, dst, 5, 10, 5, Core.BORDER_REFLECT);
 
180
 
 
181
        assertMatEqual(gray255, dst);
 
182
        // TODO_: write better test
 
183
    }
 
184
 
 
185
    public void testBlurMatMatSize() {
 
186
        Imgproc.blur(gray0, dst, size);
 
187
        assertMatEqual(gray0, dst);
 
188
 
 
189
        Imgproc.blur(gray255, dst, size);
 
190
        assertMatEqual(gray255, dst);
 
191
        // TODO_: write better test
 
192
    }
 
193
 
 
194
    public void testBlurMatMatSizePoint() {
 
195
        Imgproc.blur(gray0, dst, size, anchorPoint);
 
196
        assertMatEqual(gray0, dst);
 
197
        // TODO_: write better test
 
198
    }
 
199
 
 
200
    public void testBlurMatMatSizePointInt() {
 
201
        Imgproc.blur(gray0, dst, size, anchorPoint, Core.BORDER_REFLECT);
 
202
        assertMatEqual(gray0, dst);
 
203
        // TODO_: write better test
 
204
    }
 
205
 
 
206
    public void testBoundingRect() {
 
207
        MatOfPoint points = new MatOfPoint(new Point(0, 0), new Point(0, 4), new Point(4, 0), new Point(4, 4));
 
208
        Point p1 = new Point(1, 1);
 
209
        Point p2 = new Point(-5, -2);
 
210
 
 
211
        Rect bbox = Imgproc.boundingRect(points);
 
212
 
 
213
        assertTrue(bbox.contains(p1));
 
214
        assertFalse(bbox.contains(p2));
 
215
    }
 
216
 
 
217
    public void testBoxFilterMatMatIntSize() {
 
218
        Size size = new Size(3, 3);
 
219
        Imgproc.boxFilter(gray0, dst, 8, size);
 
220
        assertMatEqual(gray0, dst);
 
221
        // TODO_: write better test
 
222
    }
 
223
 
 
224
    public void testBoxFilterMatMatIntSizePointBoolean() {
 
225
        Imgproc.boxFilter(gray255, dst, 8, size, anchorPoint, false);
 
226
        assertMatEqual(gray255, dst);
 
227
        // TODO_: write better test
 
228
    }
 
229
 
 
230
    public void testBoxFilterMatMatIntSizePointBooleanInt() {
 
231
        Imgproc.boxFilter(gray255, dst, 8, size, anchorPoint, false, Core.BORDER_REFLECT);
 
232
        assertMatEqual(gray255, dst);
 
233
        // TODO_: write better test
 
234
    }
 
235
 
 
236
    public void testCalcBackProject() {
 
237
        List<Mat> images = Arrays.asList(grayChess);
 
238
        MatOfInt channels = new MatOfInt(0);
 
239
        MatOfInt histSize = new MatOfInt(10);
 
240
        MatOfFloat ranges = new MatOfFloat(0f, 256f);
 
241
 
 
242
        Mat hist = new Mat();
 
243
        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
 
244
        Core.normalize(hist, hist);
 
245
 
 
246
        Imgproc.calcBackProject(images, channels, hist, dst, ranges, 255);
 
247
 
 
248
        assertEquals(grayChess.size(), dst.size());
 
249
        assertEquals(grayChess.depth(), dst.depth());
 
250
        assertFalse(0 == Core.countNonZero(dst));
 
251
    }
 
252
 
 
253
    public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat() {
 
254
        List<Mat> images = Arrays.asList(gray128);
 
255
        MatOfInt channels = new MatOfInt(0);
 
256
        MatOfInt histSize = new MatOfInt(10);
 
257
        MatOfFloat ranges = new MatOfFloat(0f, 256f);
 
258
        Mat hist = new Mat();
 
259
 
 
260
        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
 
261
 
 
262
        truth = new Mat(10, 1, CvType.CV_32F, Scalar.all(0)) {
 
263
            {
 
264
                put(5, 0, 100);
 
265
            }
 
266
        };
 
267
        assertMatEqual(truth, hist, EPS);
 
268
    }
 
269
 
 
270
    public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2D() {
 
271
        List<Mat> images = Arrays.asList(gray255, gray128);
 
272
        MatOfInt channels = new MatOfInt(0, 1);
 
273
        MatOfInt histSize = new MatOfInt(10, 10);
 
274
        MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
 
275
        Mat hist = new Mat();
 
276
 
 
277
        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
 
278
 
 
279
        truth = new Mat(10, 10, CvType.CV_32F, Scalar.all(0)) {
 
280
            {
 
281
                put(9, 5, 100);
 
282
            }
 
283
        };
 
284
        assertMatEqual(truth, hist, EPS);
 
285
    }
 
286
 
 
287
    public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat3D() {
 
288
        List<Mat> images = Arrays.asList(rgbLena);
 
289
 
 
290
        Mat hist3D = new Mat();
 
291
        List<Mat> histList = Arrays.asList( new Mat[] {new Mat(), new Mat(), new Mat()} );
 
292
 
 
293
        MatOfInt histSize = new MatOfInt(10);
 
294
        MatOfFloat ranges = new MatOfFloat(0f, 256f);
 
295
 
 
296
        for(int i=0; i<rgbLena.channels(); i++)
 
297
        {
 
298
            Imgproc.calcHist(images, new MatOfInt(i), new Mat(), histList.get(i), histSize, ranges);
 
299
 
 
300
            assertEquals(10, histList.get(i).checkVector(1));
 
301
        }
 
302
 
 
303
        Core.merge(histList, hist3D);
 
304
 
 
305
        assertEquals(CvType.CV_32FC3, hist3D.type());
 
306
        assertEquals(10, hist3D.checkVector(3));
 
307
 
 
308
        Mat truth = new Mat(10, 1, CvType.CV_32FC3);
 
309
        truth.put(0, 0,
 
310
                 0, 24870, 0,
 
311
                 1863, 31926, 1,
 
312
                 56682, 37677, 2260,
 
313
                 77278, 44751, 32436,
 
314
                 69397, 41343, 18526,
 
315
                 27180, 40407, 18658,
 
316
                 21101, 15993, 32042,
 
317
                 8343, 18585, 47786,
 
318
                 300, 6567, 80988,
 
319
                 0, 25, 29447
 
320
                );
 
321
 
 
322
        assertMatEqual(truth, hist3D, EPS);
 
323
    }
 
324
 
 
325
    public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloatBoolean() {
 
326
        List<Mat> images = Arrays.asList(gray255, gray128);
 
327
        MatOfInt channels = new MatOfInt(0, 1);
 
328
        MatOfInt histSize = new MatOfInt(10, 10);
 
329
        MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
 
330
        Mat hist = new Mat();
 
331
 
 
332
        Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges, true);
 
333
 
 
334
        truth = new Mat(10, 10, CvType.CV_32F, Scalar.all(0)) {
 
335
            {
 
336
                put(9, 5, 100);
 
337
            }
 
338
        };
 
339
        assertMatEqual(truth, hist, EPS);
 
340
    }
 
341
 
 
342
    public void testCannyMatMatDoubleDouble() {
 
343
        Imgproc.Canny(gray255, dst, 5, 10);
 
344
        assertMatEqual(gray0, dst);
 
345
        // TODO_: write better test
 
346
    }
 
347
 
 
348
    public void testCannyMatMatDoubleDoubleIntBoolean() {
 
349
        Imgproc.Canny(gray0, dst, 5, 10, 5, true);
 
350
        assertMatEqual(gray0, dst);
 
351
        // TODO_: write better test
 
352
    }
 
353
 
 
354
    public void testCompareHist() {
 
355
        Mat H1 = new Mat(3, 1, CvType.CV_32F);
 
356
        Mat H2 = new Mat(3, 1, CvType.CV_32F);
 
357
        H1.put(0, 0, 1, 2, 3);
 
358
        H2.put(0, 0, 4, 5, 6);
 
359
 
 
360
        double distance = Imgproc.compareHist(H1, H2, Imgproc.CV_COMP_CORREL);
 
361
 
 
362
        assertEquals(1., distance);
 
363
    }
 
364
 
 
365
    public void testContourAreaMat() {
 
366
        Mat contour = new Mat(1, 4, CvType.CV_32FC2);
 
367
        contour.put(0, 0, 0, 0, 10, 0, 10, 10, 5, 4);
 
368
 
 
369
        double area = Imgproc.contourArea(contour);
 
370
 
 
371
        assertEquals(45., area);
 
372
    }
 
373
 
 
374
    public void testContourAreaMatBoolean() {
 
375
        Mat contour = new Mat(1, 4, CvType.CV_32FC2);
 
376
        contour.put(0, 0, 0, 0, 10, 0, 10, 10, 5, 4);
 
377
 
 
378
        double area = Imgproc.contourArea(contour, true);
 
379
 
 
380
        assertEquals(45., area);
 
381
        // TODO_: write better test
 
382
    }
 
383
 
 
384
    public void testConvertMapsMatMatMatMatInt() {
 
385
        Mat map1 = new Mat(1, 4, CvType.CV_32FC1, new Scalar(1));
 
386
        Mat map2 = new Mat(1, 4, CvType.CV_32FC1, new Scalar(2));
 
387
        Mat dstmap1 = new Mat(1, 4, CvType.CV_16SC2);
 
388
        Mat dstmap2 = new Mat(1, 4, CvType.CV_16UC1);
 
389
 
 
390
        Imgproc.convertMaps(map1, map2, dstmap1, dstmap2, CvType.CV_16SC2);
 
391
 
 
392
        Mat truthMap1 = new Mat(1, 4, CvType.CV_16SC2);
 
393
        truthMap1.put(0, 0, 1, 2, 1, 2, 1, 2, 1, 2);
 
394
        assertMatEqual(truthMap1, dstmap1);
 
395
        Mat truthMap2 = new Mat(1, 4, CvType.CV_16UC1, new Scalar(0));
 
396
        assertMatEqual(truthMap2, dstmap2);
 
397
    }
 
398
 
 
399
    public void testConvertMapsMatMatMatMatIntBoolean() {
 
400
        Mat map1 = new Mat(1, 3, CvType.CV_32FC1, new Scalar(2));
 
401
        Mat map2 = new Mat(1, 3, CvType.CV_32FC1, new Scalar(4));
 
402
        Mat dstmap1 = new Mat(1, 3, CvType.CV_16SC2);
 
403
        Mat dstmap2 = new Mat(1, 3, CvType.CV_16UC1);
 
404
 
 
405
        Imgproc.convertMaps(map1, map2, dstmap1, dstmap2, CvType.CV_16SC2, false);
 
406
        // TODO_: write better test (last param == true)
 
407
 
 
408
        Mat truthMap1 = new Mat(1, 3, CvType.CV_16SC2);
 
409
        truthMap1.put(0, 0, 2, 4, 2, 4, 2, 4);
 
410
        assertMatEqual(truthMap1, dstmap1);
 
411
        Mat truthMap2 = new Mat(1, 3, CvType.CV_16UC1, new Scalar(0));
 
412
        assertMatEqual(truthMap2, dstmap2);
 
413
    }
 
414
 
 
415
    public void testConvexHullMatMat() {
 
416
        MatOfPoint points = new MatOfPoint(
 
417
                new Point(20, 0),
 
418
                new Point(40, 0),
 
419
                new Point(30, 20),
 
420
                new Point(0,  20),
 
421
                new Point(20, 10),
 
422
                new Point(30, 10)
 
423
        );
 
424
 
 
425
        MatOfInt hull = new MatOfInt();
 
426
 
 
427
        Imgproc.convexHull(points, hull);
 
428
 
 
429
        MatOfInt expHull = new MatOfInt(
 
430
                1, 2, 3, 0
 
431
        );
 
432
        assertMatEqual(expHull, hull, EPS);
 
433
    }
 
434
 
 
435
    public void testConvexHullMatMatBooleanBoolean() {
 
436
        MatOfPoint points = new MatOfPoint(
 
437
                new Point(2, 0),
 
438
                new Point(4, 0),
 
439
                new Point(3, 2),
 
440
                new Point(0, 2),
 
441
                new Point(2, 1),
 
442
                new Point(3, 1)
 
443
        );
 
444
 
 
445
        MatOfInt hull = new MatOfInt();
 
446
 
 
447
        Imgproc.convexHull(points, hull, true);
 
448
 
 
449
        MatOfInt expHull = new MatOfInt(
 
450
                3, 2, 1, 0
 
451
        );
 
452
        assertMatEqual(expHull, hull, EPS);
 
453
    }
 
454
 
 
455
    public void testConvexityDefects() {
 
456
        MatOfPoint points = new MatOfPoint(
 
457
                new Point(20, 0),
 
458
                new Point(40, 0),
 
459
                new Point(30, 20),
 
460
                new Point(0,  20),
 
461
                new Point(20, 10),
 
462
                new Point(30, 10)
 
463
        );
 
464
 
 
465
        MatOfInt hull = new MatOfInt();
 
466
        Imgproc.convexHull(points, hull);
 
467
 
 
468
        MatOfInt4 convexityDefects = new MatOfInt4();
 
469
        Imgproc.convexityDefects(points, hull, convexityDefects);
 
470
 
 
471
        assertMatEqual(new MatOfInt4(3, 0, 5, 3620), convexityDefects);
 
472
    }
 
473
 
 
474
    public void testCornerEigenValsAndVecsMatMatIntInt() {
 
475
        fail("Not yet implemented");
 
476
        // TODO: write better test
 
477
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1);
 
478
        src.put(0, 0, 1, 2);
 
479
        src.put(1, 0, 4, 2);
 
480
 
 
481
        int blockSize = 3;
 
482
        int ksize = 5;
 
483
 
 
484
        // TODO: eigen vals and vectors returned = 0 for most src matrices
 
485
        Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize);
 
486
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC(6), new Scalar(0));
 
487
        assertMatEqual(truth, dst, EPS);
 
488
    }
 
489
 
 
490
    public void testCornerEigenValsAndVecsMatMatIntIntInt() {
 
491
        fail("Not yet implemented");
 
492
        // TODO: write better test
 
493
        Mat src = new Mat(4, 4, CvType.CV_32FC1, new Scalar(128));
 
494
 
 
495
        int blockSize = 3;
 
496
        int ksize = 5;
 
497
 
 
498
        truth = new Mat(4, 4, CvType.CV_32FC(6), new Scalar(0));
 
499
 
 
500
        Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize, Core.BORDER_REFLECT);
 
501
        assertMatEqual(truth, dst, EPS);
 
502
    }
 
503
 
 
504
    public void testCornerHarrisMatMatIntIntDouble() {
 
505
        fail("Not yet implemented");
 
506
        // TODO: write better test
 
507
 
 
508
        truth = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
 
509
        int blockSize = 5;
 
510
        int ksize = 7;
 
511
        double k = 0.1;
 
512
        Imgproc.cornerHarris(gray128, dst, blockSize, ksize, k);
 
513
        assertMatEqual(truth, dst, EPS);
 
514
    }
 
515
 
 
516
    public void testCornerHarrisMatMatIntIntDoubleInt() {
 
517
        fail("Not yet implemented");
 
518
        // TODO: write better test
 
519
 
 
520
        truth = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
 
521
        int blockSize = 5;
 
522
        int ksize = 7;
 
523
        double k = 0.1;
 
524
        Imgproc.cornerHarris(gray255, dst, blockSize, ksize, k, Core.BORDER_REFLECT);
 
525
        assertMatEqual(truth, dst, EPS);
 
526
    }
 
527
 
 
528
    public void testCornerMinEigenValMatMatInt() {
 
529
        fail("Not yet implemented");
 
530
        // TODO: write better test
 
531
 
 
532
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1);
 
533
        src.put(0, 0, 1, 2);
 
534
        src.put(1, 0, 2, 1);
 
535
        int blockSize = 5;
 
536
 
 
537
        Imgproc.cornerMinEigenVal(src, dst, blockSize);
 
538
 
 
539
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1, new Scalar(0));
 
540
        assertMatEqual(truth, dst, EPS);
 
541
 
 
542
        Imgproc.cornerMinEigenVal(gray255, dst, blockSize);
 
543
 
 
544
        truth = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
 
545
        assertMatEqual(truth, dst, EPS);
 
546
    }
 
547
 
 
548
    public void testCornerMinEigenValMatMatIntInt() {
 
549
        Mat src = Mat.eye(3, 3, CvType.CV_32FC1);
 
550
        int blockSize = 3;
 
551
        int ksize = 5;
 
552
 
 
553
        Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize);
 
554
 
 
555
        truth = new Mat(3, 3, CvType.CV_32FC1) {
 
556
            {
 
557
                put(0, 0, 1. / 18, 1. / 36, 1. / 18);
 
558
                put(1, 0, 1. / 36, 1. / 18, 1. / 36);
 
559
                put(2, 0, 1. / 18, 1. / 36, 1. / 18);
 
560
            }
 
561
        };
 
562
        assertMatEqual(truth, dst, EPS);
 
563
    }
 
564
 
 
565
    public void testCornerMinEigenValMatMatIntIntInt() {
 
566
        Mat src = Mat.eye(3, 3, CvType.CV_32FC1);
 
567
        int blockSize = 3;
 
568
        int ksize = 5;
 
569
 
 
570
        Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize, Core.BORDER_REFLECT);
 
571
 
 
572
        truth = new Mat(3, 3, CvType.CV_32FC1) {
 
573
            {
 
574
                put(0, 0, 0.68055558, 0.92708349, 0.5868057);
 
575
                put(1, 0, 0.92708343, 0.92708343, 0.92708343);
 
576
                put(2, 0, 0.58680564, 0.92708343, 0.68055564);
 
577
            }
 
578
        };
 
579
        assertMatEqual(truth, dst, EPS);
 
580
    }
 
581
 
 
582
    public void testCornerSubPix() {
 
583
        Mat img = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(128));
 
584
        Point truthPosition = new Point(img.cols() / 2, img.rows() / 2);
 
585
 
 
586
        Rect r = new Rect(new Point(0, 0), truthPosition);
 
587
        Imgproc.rectangle(img, r.tl(), r.br(), new Scalar(0), Core.FILLED);
 
588
        MatOfPoint2f corners = new MatOfPoint2f(new Point(truthPosition.x + 1, truthPosition.y + 1));
 
589
        Size winSize = new Size(2, 2);
 
590
        Size zeroZone = new Size(-1, -1);
 
591
        TermCriteria criteria = new TermCriteria(TermCriteria.EPS, 0, 0.01);
 
592
 
 
593
        Imgproc.cornerSubPix(img, corners, winSize, zeroZone, criteria);
 
594
 
 
595
        assertPointEquals(truthPosition, corners.toList().get(0), weakEPS);
 
596
    }
 
597
 
 
598
    public void testCvtColorMatMatInt() {
 
599
        fail("Not yet implemented");
 
600
    }
 
601
 
 
602
    public void testCvtColorMatMatIntInt() {
 
603
        fail("Not yet implemented");
 
604
    }
 
605
 
 
606
    public void testDilateMatMatMat() {
 
607
        Mat kernel = new Mat();
 
608
 
 
609
        Imgproc.dilate(gray255, dst, kernel);
 
610
 
 
611
        assertMatEqual(gray255, dst);
 
612
 
 
613
        Imgproc.dilate(gray1, dst, kernel);
 
614
 
 
615
        assertMatEqual(gray1, dst);
 
616
        // TODO_: write better test
 
617
    }
 
618
 
 
619
    public void testDilateMatMatMatPoint() {
 
620
        fail("Not yet implemented");
 
621
    }
 
622
 
 
623
    public void testDilateMatMatMatPointInt() {
 
624
        fail("Not yet implemented");
 
625
    }
 
626
 
 
627
    public void testDilateMatMatMatPointIntInt() {
 
628
        fail("Not yet implemented");
 
629
    }
 
630
 
 
631
    public void testDilateMatMatMatPointIntIntScalar() {
 
632
        fail("Not yet implemented");
 
633
    }
 
634
 
 
635
    public void testDistanceTransformWithLabels() {
 
636
        Mat dstLables = getMat(CvType.CV_32SC1, 0);
 
637
        Mat labels = new Mat();
 
638
 
 
639
        Imgproc.distanceTransformWithLabels(gray128, dst, labels, Imgproc.CV_DIST_L2, 3);
 
640
 
 
641
        assertMatEqual(dstLables, labels);
 
642
        assertMatEqual(getMat(CvType.CV_32FC1, 8192), dst, EPS);
 
643
    }
 
644
 
 
645
    public void testDrawContoursMatListOfMatIntScalar() {
 
646
        Imgproc.rectangle(gray0, new Point(1, 2), new Point(7, 8), new Scalar(100));
 
647
        List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
 
648
        Imgproc.findContours(gray0, contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 
649
 
 
650
        Imgproc.drawContours(gray0, contours, -1, new Scalar(0));
 
651
 
 
652
        assertEquals(0, Core.countNonZero(gray0));
 
653
    }
 
654
 
 
655
    public void testDrawContoursMatListOfMatIntScalarInt() {
 
656
        Imgproc.rectangle(gray0, new Point(1, 2), new Point(7, 8), new Scalar(100));
 
657
        List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
 
658
        Imgproc.findContours(gray0, contours, new Mat(), Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 
659
 
 
660
        Imgproc.drawContours(gray0, contours, -1, new Scalar(0), Core.FILLED);
 
661
 
 
662
        assertEquals(0, Core.countNonZero(gray0));
 
663
    }
 
664
 
 
665
 
 
666
    public void testDrawContoursMatListOfMatIntScalarIntIntMatIntPoint() {
 
667
        fail("Not yet implemented");
 
668
    }
 
669
 
 
670
    public void testEqualizeHist() {
 
671
        Imgproc.equalizeHist(gray0, dst);
 
672
        assertMatEqual(gray0, dst);
 
673
 
 
674
        Imgproc.equalizeHist(gray255, dst);
 
675
        assertMatEqual(gray255, dst);
 
676
        // TODO_: write better test
 
677
    }
 
678
 
 
679
    public void testErodeMatMatMat() {
 
680
        Mat kernel = new Mat();
 
681
 
 
682
        Imgproc.erode(gray128, dst, kernel);
 
683
 
 
684
        assertMatEqual(gray128, dst);
 
685
    }
 
686
 
 
687
    public void testErodeMatMatMatPointInt() {
 
688
        Mat src = new Mat(3, 3, CvType.CV_8U) {
 
689
            {
 
690
                put(0, 0, 15, 9, 10);
 
691
                put(1, 0, 10, 8, 12);
 
692
                put(2, 0, 12, 20, 25);
 
693
            }
 
694
        };
 
695
        Mat kernel = new Mat();
 
696
 
 
697
        Imgproc.erode(src, dst, kernel, anchorPoint, 10);
 
698
 
 
699
        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(8));
 
700
        assertMatEqual(truth, dst);
 
701
    }
 
702
 
 
703
    public void testErodeMatMatMatPointIntIntScalar() {
 
704
        Mat src = new Mat(3, 3, CvType.CV_8U) {
 
705
            {
 
706
                put(0, 0, 15, 9, 10);
 
707
                put(1, 0, 10, 8, 12);
 
708
                put(2, 0, 12, 20, 25);
 
709
            }
 
710
        };
 
711
        Mat kernel = new Mat();
 
712
        Scalar sc = new Scalar(3, 3);
 
713
 
 
714
        Imgproc.erode(src, dst, kernel, anchorPoint, 10, Core.BORDER_REFLECT, sc);
 
715
 
 
716
        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(8));
 
717
        assertMatEqual(truth, dst);
 
718
    }
 
719
 
 
720
    public void testFilter2DMatMatIntMat() {
 
721
        Mat src = Mat.eye(4, 4, CvType.CV_32F);
 
722
        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
 
723
 
 
724
        Imgproc.filter2D(src, dst, -1, kernel);
 
725
 
 
726
        truth = new Mat(4, 4, CvType.CV_32F) {
 
727
            {
 
728
                put(0, 0, 2, 2, 1, 0);
 
729
                put(1, 0, 2, 2, 1, 0);
 
730
                put(2, 0, 1, 1, 2, 1);
 
731
                put(3, 0, 0, 0, 1, 2);
 
732
            }
 
733
        };
 
734
        assertMatEqual(truth, dst, EPS);
 
735
    }
 
736
 
 
737
    public void testFilter2DMatMatIntMatPointDouble() {
 
738
        fail("Not yet implemented");
 
739
    }
 
740
 
 
741
    public void testFilter2DMatMatIntMatPointDoubleInt() {
 
742
        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
 
743
        Point point = new Point(0, 0);
 
744
 
 
745
        Imgproc.filter2D(gray128, dst, -1, kernel, point, 2, Core.BORDER_CONSTANT);
 
746
 
 
747
        assertMatEqual(gray2, dst);
 
748
    }
 
749
 
 
750
    public void testFindContoursMatListOfMatMatIntInt() {
 
751
        Mat img = new Mat(50, 50, CvType.CV_8UC1, new Scalar(0));
 
752
        List<MatOfPoint> contours = new ArrayList<MatOfPoint>(5);
 
753
        Mat hierarchy = new Mat();
 
754
 
 
755
        Imgproc.findContours(img, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 
756
 
 
757
        // no contours on empty image
 
758
        assertEquals(contours.size(), 0);
 
759
        assertEquals(contours.size(), hierarchy.total());
 
760
 
 
761
        Imgproc.rectangle(img, new Point(10, 20), new Point(20, 30), new Scalar(100), 3, Imgproc.LINE_AA, 0);
 
762
        Imgproc.rectangle(img, new Point(30, 35), new Point(40, 45), new Scalar(200));
 
763
 
 
764
        Imgproc.findContours(img, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 
765
 
 
766
        // two contours of two rectangles
 
767
        assertEquals(contours.size(), 2);
 
768
        assertEquals(contours.size(), hierarchy.total());
 
769
    }
 
770
 
 
771
    public void testFindContoursMatListOfMatMatIntIntPoint() {
 
772
        Mat img = new Mat(50, 50, CvType.CV_8UC1, new Scalar(0));
 
773
        Mat img2 = img.submat(5, 50, 3, 50);
 
774
        List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
 
775
        List<MatOfPoint> contours2 = new ArrayList<MatOfPoint>();
 
776
        Mat hierarchy = new Mat();
 
777
 
 
778
        Imgproc.rectangle(img, new Point(10, 20), new Point(20, 30), new Scalar(100), 3, Imgproc.LINE_AA, 0);
 
779
        Imgproc.rectangle(img, new Point(30, 35), new Point(40, 45), new Scalar(200));
 
780
 
 
781
        Imgproc.findContours(img, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
 
782
        Imgproc.findContours(img2, contours2, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE, new Point(3, 5));
 
783
 
 
784
        assertEquals(contours.size(), contours2.size());
 
785
        assertMatEqual(contours.get(0), contours2.get(0));
 
786
        /*
 
787
        Log.d("findContours", "hierarchy=" + hierarchy);
 
788
        int iBuff[] = new int[ (int) (hierarchy.total() * hierarchy.channels()) ]; // [ Contour0 (next sibling num, previous sibling num, 1st child num, parent num), Contour1(...), ...
 
789
        hierarchy.get(0, 0, iBuff);
 
790
        Log.d("findContours", Arrays.toString(iBuff));
 
791
        */
 
792
    }
 
793
 
 
794
    public void testFitEllipse() {
 
795
        MatOfPoint2f points = new MatOfPoint2f(new Point(0, 0), new Point(-1, 1), new Point(1, 1), new Point(1, -1), new Point(-1, -1));
 
796
        RotatedRect rrect = new RotatedRect();
 
797
 
 
798
        rrect = Imgproc.fitEllipse(points);
 
799
 
 
800
        assertPointEquals(new Point(0, 0), rrect.center, EPS);
 
801
        assertEquals(2.828, rrect.size.width, EPS);
 
802
        assertEquals(2.828, rrect.size.height, EPS);
 
803
    }
 
804
 
 
805
    public void testFitLine() {
 
806
        Mat points = new Mat(1, 4, CvType.CV_32FC2);
 
807
        points.put(0, 0, 0, 0, 2, 3, 3, 4, 5, 8);
 
808
 
 
809
        Mat linePoints = new Mat(4, 1, CvType.CV_32FC1);
 
810
        linePoints.put(0, 0, 0.53196341, 0.84676737, 2.496531, 3.7467217);
 
811
 
 
812
        Imgproc.fitLine(points, dst, Imgproc.CV_DIST_L12, 0, 0.01, 0.01);
 
813
 
 
814
        assertMatEqual(linePoints, dst, EPS);
 
815
    }
 
816
 
 
817
    public void testFloodFillMatMatPointScalar() {
 
818
        Mat mask = new Mat(matSize + 2, matSize + 2, CvType.CV_8U, new Scalar(0));
 
819
        Mat img = gray0;
 
820
        Imgproc.circle(mask, new Point(matSize / 2 + 1, matSize / 2 + 1), 3, new Scalar(2));
 
821
 
 
822
        int retval = Imgproc.floodFill(img, mask, new Point(matSize / 2, matSize / 2), new Scalar(1));
 
823
 
 
824
        assertEquals(Core.countNonZero(img), retval);
 
825
        Imgproc.circle(mask, new Point(matSize / 2 + 1, matSize / 2 + 1), 3, new Scalar(0));
 
826
        assertEquals(retval + 4 * (matSize + 1), Core.countNonZero(mask));
 
827
        assertMatEqual(mask.submat(1, matSize + 1, 1, matSize + 1), img);
 
828
    }
 
829
 
 
830
    public void testFloodFillMatMatPointScalar_WithoutMask() {
 
831
        Mat img = gray0;
 
832
        Imgproc.circle(img, new Point(matSize / 2, matSize / 2), 3, new Scalar(2));
 
833
 
 
834
        // TODO: ideally we should pass null instead of "new Mat()"
 
835
        int retval = Imgproc.floodFill(img, new Mat(), new Point(matSize / 2, matSize / 2), new Scalar(1));
 
836
 
 
837
        Imgproc.circle(img, new Point(matSize / 2, matSize / 2), 3, new Scalar(0));
 
838
        assertEquals(Core.countNonZero(img), retval);
 
839
    }
 
840
 
 
841
    public void testFloodFillMatMatPointScalarRect() {
 
842
        fail("Not yet implemented");
 
843
    }
 
844
 
 
845
    public void testFloodFillMatMatPointScalarRectScalar() {
 
846
        fail("Not yet implemented");
 
847
    }
 
848
 
 
849
    public void testFloodFillMatMatPointScalarRectScalarScalar() {
 
850
        fail("Not yet implemented");
 
851
    }
 
852
 
 
853
    public void testFloodFillMatMatPointScalarRectScalarScalarInt() {
 
854
        fail("Not yet implemented");
 
855
    }
 
856
 
 
857
    public void testGaussianBlurMatMatSizeDouble() {
 
858
        Imgproc.GaussianBlur(gray0, dst, size, 1);
 
859
        assertMatEqual(gray0, dst);
 
860
 
 
861
        Imgproc.GaussianBlur(gray2, dst, size, 1);
 
862
        assertMatEqual(gray2, dst);
 
863
    }
 
864
 
 
865
    public void testGaussianBlurMatMatSizeDoubleDouble() {
 
866
        Imgproc.GaussianBlur(gray2, dst, size, 0, 0);
 
867
 
 
868
        assertMatEqual(gray2, dst);
 
869
        // TODO_: write better test
 
870
    }
 
871
 
 
872
    public void testGaussianBlurMatMatSizeDoubleDoubleInt() {
 
873
        Imgproc.GaussianBlur(gray2, dst, size, 1, 3, Core.BORDER_REFLECT);
 
874
 
 
875
        assertMatEqual(gray2, dst);
 
876
        // TODO_: write better test
 
877
    }
 
878
 
 
879
    public void testGetAffineTransform() {
 
880
        MatOfPoint2f src = new MatOfPoint2f(new Point(2, 3), new Point(3, 1), new Point(1, 4));
 
881
        MatOfPoint2f dst = new MatOfPoint2f(new Point(3, 3), new Point(7, 4), new Point(5, 6));
 
882
 
 
883
        Mat transform = Imgproc.getAffineTransform(src, dst);
 
884
 
 
885
        Mat truth = new Mat(2, 3, CvType.CV_64FC1) {
 
886
            {
 
887
                put(0, 0, -8, -6, 37);
 
888
                put(1, 0, -7, -4, 29);
 
889
            }
 
890
        };
 
891
        assertMatEqual(truth, transform, EPS);
 
892
    }
 
893
 
 
894
    public void testGetDefaultNewCameraMatrixMat() {
 
895
        Mat mtx = Imgproc.getDefaultNewCameraMatrix(gray0);
 
896
 
 
897
        assertFalse(mtx.empty());
 
898
        assertEquals(0, Core.countNonZero(mtx));
 
899
    }
 
900
 
 
901
    public void testGetDefaultNewCameraMatrixMatSizeBoolean() {
 
902
        Mat mtx = Imgproc.getDefaultNewCameraMatrix(gray0, size, true);
 
903
 
 
904
        assertFalse(mtx.empty());
 
905
        assertFalse(0 == Core.countNonZero(mtx));
 
906
        // TODO_: write better test
 
907
    }
 
908
 
 
909
    public void testGetDerivKernelsMatMatIntIntInt() {
 
910
        Mat kx = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
 
911
        Mat ky = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
 
912
        Mat expKx = new Mat(3, 1, CvType.CV_32F);
 
913
        Mat expKy = new Mat(3, 1, CvType.CV_32F);
 
914
        kx.put(0, 0, 1, 1);
 
915
        kx.put(1, 0, 1, 1);
 
916
        ky.put(0, 0, 2, 2);
 
917
        ky.put(1, 0, 2, 2);
 
918
        expKx.put(0, 0, 1, -2, 1);
 
919
        expKy.put(0, 0, 1, -2, 1);
 
920
 
 
921
        Imgproc.getDerivKernels(kx, ky, 2, 2, 3);
 
922
 
 
923
        assertMatEqual(expKx, kx, EPS);
 
924
        assertMatEqual(expKy, ky, EPS);
 
925
    }
 
926
 
 
927
    public void testGetDerivKernelsMatMatIntIntIntBooleanInt() {
 
928
        Mat kx = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
 
929
        Mat ky = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
 
930
        Mat expKx = new Mat(3, 1, CvType.CV_32F);
 
931
        Mat expKy = new Mat(3, 1, CvType.CV_32F);
 
932
        kx.put(0, 0, 1, 1);
 
933
        kx.put(1, 0, 1, 1);
 
934
        ky.put(0, 0, 2, 2);
 
935
        ky.put(1, 0, 2, 2);
 
936
        expKx.put(0, 0, 1, -2, 1);
 
937
        expKy.put(0, 0, 1, -2, 1);
 
938
 
 
939
        Imgproc.getDerivKernels(kx, ky, 2, 2, 3, true, CvType.CV_32F);
 
940
 
 
941
        assertMatEqual(expKx, kx, EPS);
 
942
        assertMatEqual(expKy, ky, EPS);
 
943
        // TODO_: write better test
 
944
    }
 
945
 
 
946
    public void testGetGaussianKernelIntDouble() {
 
947
        dst = Imgproc.getGaussianKernel(1, 0.5);
 
948
 
 
949
        truth = new Mat(1, 1, CvType.CV_64FC1, new Scalar(1));
 
950
        assertMatEqual(truth, dst, EPS);
 
951
    }
 
952
 
 
953
    public void testGetGaussianKernelIntDoubleInt() {
 
954
        dst = Imgproc.getGaussianKernel(3, 0.8, CvType.CV_32F);
 
955
 
 
956
        truth = new Mat(3, 1, CvType.CV_32F);
 
957
        truth.put(0, 0, 0.23899426, 0.52201146, 0.23899426);
 
958
        assertMatEqual(truth, dst, EPS);
 
959
    }
 
960
 
 
961
    public void testGetPerspectiveTransform() {
 
962
        fail("Not yet implemented");
 
963
    }
 
964
 
 
965
    public void testGetRectSubPixMatSizePointMat() {
 
966
        Size size = new Size(3, 3);
 
967
        Point center = new Point(gray255.cols() / 2, gray255.rows() / 2);
 
968
 
 
969
        Imgproc.getRectSubPix(gray255, size, center, dst);
 
970
 
 
971
        truth = new Mat(3, 3, CvType.CV_8U, new Scalar(255));
 
972
        assertMatEqual(truth, dst);
 
973
    }
 
974
 
 
975
    public void testGetRectSubPixMatSizePointMatInt() {
 
976
        Mat src = new Mat(10, 10, CvType.CV_32F, new Scalar(2));
 
977
        Size patchSize = new Size(5, 5);
 
978
        Point center = new Point(src.cols() / 2, src.rows() / 2);
 
979
 
 
980
        Imgproc.getRectSubPix(src, patchSize, center, dst);
 
981
 
 
982
        truth = new Mat(5, 5, CvType.CV_32F, new Scalar(2));
 
983
        assertMatEqual(truth, dst, EPS);
 
984
    }
 
985
 
 
986
    public void testGetRotationMatrix2D() {
 
987
        Point center = new Point(0, 0);
 
988
 
 
989
        dst = Imgproc.getRotationMatrix2D(center, 0, 1);
 
990
 
 
991
        truth = new Mat(2, 3, CvType.CV_64F) {
 
992
            {
 
993
                put(0, 0, 1, 0, 0);
 
994
                put(1, 0, 0, 1, 0);
 
995
            }
 
996
        };
 
997
 
 
998
        assertMatEqual(truth, dst, EPS);
 
999
    }
 
1000
 
 
1001
    public void testGetStructuringElementIntSize() {
 
1002
        dst = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, size);
 
1003
 
 
1004
        truth = new Mat(3, 3, CvType.CV_8UC1, new Scalar(1));
 
1005
        assertMatEqual(truth, dst);
 
1006
    }
 
1007
 
 
1008
    public void testGetStructuringElementIntSizePoint() {
 
1009
        dst = Imgproc.getStructuringElement(Imgproc.MORPH_CROSS, size, anchorPoint);
 
1010
 
 
1011
        truth = new Mat(3, 3, CvType.CV_8UC1) {
 
1012
            {
 
1013
                put(0, 0, 0, 0, 1);
 
1014
                put(1, 0, 0, 0, 1);
 
1015
                put(2, 0, 1, 1, 1);
 
1016
            }
 
1017
        };
 
1018
        assertMatEqual(truth, dst);
 
1019
    }
 
1020
 
 
1021
    public void testGoodFeaturesToTrackMatListOfPointIntDoubleDouble() {
 
1022
        Mat src = gray0;
 
1023
        Imgproc.rectangle(src, new Point(2, 2), new Point(8, 8), new Scalar(100), -1);
 
1024
        MatOfPoint lp = new MatOfPoint();
 
1025
 
 
1026
        Imgproc.goodFeaturesToTrack(src, lp, 100, 0.01, 3);
 
1027
 
 
1028
        assertEquals(4, lp.total());
 
1029
    }
 
1030
 
 
1031
    public void testGoodFeaturesToTrackMatListOfPointIntDoubleDoubleMatIntBooleanDouble() {
 
1032
        Mat src = gray0;
 
1033
        Imgproc.rectangle(src, new Point(2, 2), new Point(8, 8), new Scalar(100), -1);
 
1034
        MatOfPoint lp = new MatOfPoint();
 
1035
 
 
1036
        Imgproc.goodFeaturesToTrack(src, lp, 100, 0.01, 3, gray1, 4, true, 0);
 
1037
 
 
1038
        assertEquals(4, lp.total());
 
1039
    }
 
1040
 
 
1041
    public void testGrabCutMatMatRectMatMatInt() {
 
1042
        fail("Not yet implemented");
 
1043
    }
 
1044
 
 
1045
    public void testGrabCutMatMatRectMatMatIntInt() {
 
1046
        fail("Not yet implemented");
 
1047
    }
 
1048
 
 
1049
    public void testHoughCirclesMatMatIntDoubleDouble() {
 
1050
        int sz = 512;
 
1051
        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
 
1052
        Mat circles = new Mat();
 
1053
 
 
1054
        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4);
 
1055
 
 
1056
        assertEquals(0, circles.cols());
 
1057
    }
 
1058
 
 
1059
    public void testHoughCirclesMatMatIntDoubleDouble1() {
 
1060
        int sz = 512;
 
1061
        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(128));
 
1062
        Mat circles = new Mat();
 
1063
 
 
1064
        Point center = new Point(img.cols() / 2, img.rows() / 2);
 
1065
        int radius = Math.min(img.cols() / 4, img.rows() / 4);
 
1066
        Imgproc.circle(img, center, radius, colorBlack, 3);
 
1067
 
 
1068
        Imgproc.HoughCircles(img, circles, Imgproc.CV_HOUGH_GRADIENT, 2, img.rows() / 4);
 
1069
 
 
1070
        assertEquals(1, circles.cols());
 
1071
    }
 
1072
 
 
1073
    public void testHoughCirclesMatMatIntDoubleDoubleDoubleDoubleIntInt() {
 
1074
        fail("Not yet implemented");
 
1075
    }
 
1076
 
 
1077
    public void testHoughLinesMatMatDoubleDoubleInt() {
 
1078
        int sz = 512;
 
1079
        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(0));
 
1080
        Point point1 = new Point(50, 50);
 
1081
        Point point2 = new Point(img.cols() / 2, img.rows() / 2);
 
1082
        Imgproc.line(img, point1, point2, colorWhite, 1);
 
1083
        Mat lines = new Mat();
 
1084
 
 
1085
        Imgproc.HoughLines(img, lines, 1, 3.1415926/180, 100);
 
1086
 
 
1087
        assertEquals(1, lines.cols());
 
1088
 
 
1089
        /*
 
1090
        Log.d("HoughLines", "lines=" + lines);
 
1091
        int num = (int)lines.total();
 
1092
        int buff[] = new int[num*4]; //[ (x1, y1, x2, y2), (...), ...]
 
1093
        lines.get(0, 0, buff);
 
1094
        Log.d("HoughLines", "lines=" + Arrays.toString(buff));
 
1095
        */
 
1096
    }
 
1097
 
 
1098
    public void testHoughLinesMatMatDoubleDoubleIntDouble() {
 
1099
        fail("Not yet implemented");
 
1100
    }
 
1101
 
 
1102
    public void testHoughLinesMatMatDoubleDoubleIntDoubleDouble() {
 
1103
        fail("Not yet implemented");
 
1104
    }
 
1105
 
 
1106
    public void testHoughLinesPMatMatDoubleDoubleInt() {
 
1107
        int sz = 512;
 
1108
        Mat img = new Mat(sz, sz, CvType.CV_8U, new Scalar(0));
 
1109
        Point point1 = new Point(0, 0);
 
1110
        Point point2 = new Point(sz, sz);
 
1111
        Point point3 = new Point(sz, 0);
 
1112
        Point point4 = new Point(2*sz/3, sz/3);
 
1113
        Imgproc.line(img, point1, point2, Scalar.all(255), 1);
 
1114
        Imgproc.line(img, point3, point4, Scalar.all(255), 1);
 
1115
        Mat lines = new Mat();
 
1116
 
 
1117
        Imgproc.HoughLinesP(img, lines, 1, 3.1415926/180, 100);
 
1118
 
 
1119
        assertEquals(2, lines.cols());
 
1120
 
 
1121
        /*
 
1122
        Log.d("HoughLinesP", "lines=" + lines);
 
1123
        int num = (int)lines.cols();
 
1124
        int buff[] = new int[num*4]; // CV_32SC4 as [ (x1, y1, x2, y2), (...), ...]
 
1125
        lines.get(0, 0, buff);
 
1126
        Log.d("HoughLinesP", "lines=" + Arrays.toString(buff));
 
1127
        */
 
1128
    }
 
1129
 
 
1130
    public void testHoughLinesPMatMatDoubleDoubleIntDouble() {
 
1131
        fail("Not yet implemented");
 
1132
    }
 
1133
 
 
1134
    public void testHoughLinesPMatMatDoubleDoubleIntDoubleDouble() {
 
1135
        fail("Not yet implemented");
 
1136
    }
 
1137
 
 
1138
    public void testHuMoments() {
 
1139
        fail("Not yet implemented");
 
1140
    }
 
1141
 
 
1142
    public void testInitUndistortRectifyMap() {
 
1143
        fail("Not yet implemented");
 
1144
        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
 
1145
        cameraMatrix.put(0, 0, 1, 0, 1);
 
1146
        cameraMatrix.put(1, 0, 0, 1, 1);
 
1147
        cameraMatrix.put(2, 0, 0, 0, 1);
 
1148
 
 
1149
        Mat R = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
 
1150
        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
 
1151
 
 
1152
        Mat distCoeffs = new Mat();
 
1153
        Mat map1 = new Mat();
 
1154
        Mat map2 = new Mat();
 
1155
 
 
1156
        // TODO: complete this test
 
1157
        Imgproc.initUndistortRectifyMap(cameraMatrix, distCoeffs, R, newCameraMatrix, size, CvType.CV_32F, map1, map2);
 
1158
    }
 
1159
 
 
1160
    public void testInitWideAngleProjMapMatMatSizeIntIntMatMat() {
 
1161
        fail("Not yet implemented");
 
1162
        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F);
 
1163
        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F);
 
1164
        // Size imageSize = new Size(2, 2);
 
1165
 
 
1166
        cameraMatrix.put(0, 0, 1, 0, 1);
 
1167
        cameraMatrix.put(1, 0, 0, 1, 2);
 
1168
        cameraMatrix.put(2, 0, 0, 0, 1);
 
1169
 
 
1170
        distCoeffs.put(0, 0, 1, 3, 2, 4);
 
1171
        truth = new Mat(3, 3, CvType.CV_32F);
 
1172
        truth.put(0, 0, 0, 0, 0);
 
1173
        truth.put(1, 0, 0, 0, 0);
 
1174
        truth.put(2, 0, 0, 3, 0);
 
1175
        // TODO: No documentation for this function
 
1176
        // Imgproc.initWideAngleProjMap(cameraMatrix, distCoeffs, imageSize,
 
1177
        // 5, m1type, truthput1, truthput2);
 
1178
    }
 
1179
 
 
1180
    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatInt() {
 
1181
        fail("Not yet implemented");
 
1182
    }
 
1183
 
 
1184
    public void testInitWideAngleProjMapMatMatSizeIntIntMatMatIntDouble() {
 
1185
        fail("Not yet implemented");
 
1186
    }
 
1187
 
 
1188
    public void testIntegral2MatMatMat() {
 
1189
        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
 
1190
        Mat expSum = new Mat(4, 4, CvType.CV_64F);
 
1191
        Mat expSqsum = new Mat(4, 4, CvType.CV_64F);
 
1192
        Mat sum = new Mat();
 
1193
        Mat sqsum = new Mat();
 
1194
 
 
1195
        expSum.put(0, 0, 0, 0, 0, 0);
 
1196
        expSum.put(1, 0, 0, 3, 6, 9);
 
1197
        expSum.put(2, 0, 0, 6, 12, 18);
 
1198
        expSum.put(3, 0, 0, 9, 18, 27);
 
1199
 
 
1200
        expSqsum.put(0, 0, 0, 0, 0, 0);
 
1201
        expSqsum.put(1, 0, 0, 9, 18, 27);
 
1202
        expSqsum.put(2, 0, 0, 18, 36, 54);
 
1203
        expSqsum.put(3, 0, 0, 27, 54, 81);
 
1204
 
 
1205
        Imgproc.integral2(src, sum, sqsum);
 
1206
 
 
1207
        assertMatEqual(expSum, sum, EPS);
 
1208
        assertMatEqual(expSqsum, sqsum, EPS);
 
1209
    }
 
1210
 
 
1211
    public void testIntegral2MatMatMatInt() {
 
1212
        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
 
1213
        Mat expSum = new Mat(4, 4, CvType.CV_64F);
 
1214
        Mat expSqsum = new Mat(4, 4, CvType.CV_64F);
 
1215
        Mat sum = new Mat();
 
1216
        Mat sqsum = new Mat();
 
1217
 
 
1218
        expSum.put(0, 0, 0, 0, 0, 0);
 
1219
        expSum.put(1, 0, 0, 3, 6, 9);
 
1220
        expSum.put(2, 0, 0, 6, 12, 18);
 
1221
        expSum.put(3, 0, 0, 9, 18, 27);
 
1222
 
 
1223
        expSqsum.put(0, 0, 0, 0, 0, 0);
 
1224
        expSqsum.put(1, 0, 0, 9, 18, 27);
 
1225
        expSqsum.put(2, 0, 0, 18, 36, 54);
 
1226
        expSqsum.put(3, 0, 0, 27, 54, 81);
 
1227
 
 
1228
        Imgproc.integral2(src, sum, sqsum, CvType.CV_64F, CvType.CV_64F);
 
1229
 
 
1230
        assertMatEqual(expSum, sum, EPS);
 
1231
        assertMatEqual(expSqsum, sqsum, EPS);
 
1232
    }
 
1233
 
 
1234
    public void testIntegral3MatMatMatMat() {
 
1235
        Mat src = new Mat(1, 1, CvType.CV_32F, new Scalar(1));
 
1236
        Mat expSum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
 
1237
        Mat expSqsum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
 
1238
        Mat expTilted = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
 
1239
        Mat sum = new Mat();
 
1240
        Mat sqsum = new Mat();
 
1241
        Mat tilted = new Mat();
 
1242
 
 
1243
        expSum.put(0, 0, 0, 0);
 
1244
        expSum.put(1, 0, 0, 1);
 
1245
 
 
1246
        expSqsum.put(0, 0, 0, 0);
 
1247
        expSqsum.put(1, 0, 0, 1);
 
1248
 
 
1249
        expTilted.put(0, 0, 0, 0);
 
1250
        expTilted.put(1, 0, 0, 1);
 
1251
 
 
1252
        Imgproc.integral3(src, sum, sqsum, tilted);
 
1253
 
 
1254
        assertMatEqual(expSum, sum, EPS);
 
1255
        assertMatEqual(expSqsum, sqsum, EPS);
 
1256
        assertMatEqual(expTilted, tilted, EPS);
 
1257
    }
 
1258
 
 
1259
    public void testIntegral3MatMatMatMatInt() {
 
1260
        Mat src = new Mat(1, 1, CvType.CV_32F, new Scalar(1));
 
1261
        Mat expSum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
 
1262
        Mat expSqsum = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
 
1263
        Mat expTilted = new Mat(imgprocSz, imgprocSz, CvType.CV_64F);
 
1264
        Mat sum = new Mat();
 
1265
        Mat sqsum = new Mat();
 
1266
        Mat tilted = new Mat();
 
1267
 
 
1268
        expSum.put(0, 0, 0, 0);
 
1269
        expSum.put(1, 0, 0, 1);
 
1270
 
 
1271
        expSqsum.put(0, 0, 0, 0);
 
1272
        expSqsum.put(1, 0, 0, 1);
 
1273
 
 
1274
        expTilted.put(0, 0, 0, 0);
 
1275
        expTilted.put(1, 0, 0, 1);
 
1276
 
 
1277
        Imgproc.integral3(src, sum, sqsum, tilted, CvType.CV_64F, CvType.CV_64F);
 
1278
 
 
1279
        assertMatEqual(expSum, sum, EPS);
 
1280
        assertMatEqual(expSqsum, sqsum, EPS);
 
1281
        assertMatEqual(expTilted, tilted, EPS);
 
1282
    }
 
1283
 
 
1284
    public void testIntegralMatMat() {
 
1285
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
 
1286
 
 
1287
        Imgproc.integral(src, dst);
 
1288
 
 
1289
        truth = new Mat(3, 3, CvType.CV_64F) {
 
1290
            {
 
1291
                put(0, 0, 0, 0, 0);
 
1292
                put(1, 0, 0, 2, 4);
 
1293
                put(2, 0, 0, 4, 8);
 
1294
            }
 
1295
        };
 
1296
        assertMatEqual(truth, dst, EPS);
 
1297
    }
 
1298
 
 
1299
    public void testIntegralMatMatInt() {
 
1300
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
 
1301
 
 
1302
        Imgproc.integral(src, dst, CvType.CV_64F);
 
1303
 
 
1304
        truth = new Mat(3, 3, CvType.CV_64F) {
 
1305
            {
 
1306
                put(0, 0, 0, 0, 0);
 
1307
                put(1, 0, 0, 2, 4);
 
1308
                put(2, 0, 0, 4, 8);
 
1309
            }
 
1310
        };
 
1311
        assertMatEqual(truth, dst, EPS);
 
1312
    }
 
1313
 
 
1314
    public void testInvertAffineTransform() {
 
1315
        Mat src = new Mat(2, 3, CvType.CV_64F, new Scalar(1));
 
1316
 
 
1317
        Imgproc.invertAffineTransform(src, dst);
 
1318
 
 
1319
        truth = new Mat(2, 3, CvType.CV_64F, new Scalar(0));
 
1320
        assertMatEqual(truth, dst, EPS);
 
1321
    }
 
1322
 
 
1323
    public void testIsContourConvex() {
 
1324
        MatOfPoint contour1 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
 
1325
 
 
1326
        assertFalse(Imgproc.isContourConvex(contour1));
 
1327
 
 
1328
        MatOfPoint contour2 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
 
1329
 
 
1330
        assertTrue(Imgproc.isContourConvex(contour2));
 
1331
    }
 
1332
 
 
1333
    public void testLaplacianMatMatInt() {
 
1334
        Imgproc.Laplacian(gray0, dst, CvType.CV_8U);
 
1335
 
 
1336
        assertMatEqual(gray0, dst);
 
1337
    }
 
1338
 
 
1339
    public void testLaplacianMatMatIntIntDoubleDouble() {
 
1340
        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
 
1341
 
 
1342
        Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2, EPS);
 
1343
 
 
1344
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F) {
 
1345
            {
 
1346
                put(0, 0, -7.9990001, 8.0009995);
 
1347
                put(1, 0, 8.0009995, -7.9990001);
 
1348
            }
 
1349
        };
 
1350
        assertMatEqual(truth, dst, EPS);
 
1351
    }
 
1352
 
 
1353
    public void testLaplacianMatMatIntIntDoubleDoubleInt() {
 
1354
        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
 
1355
 
 
1356
        Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2, EPS, Core.BORDER_REFLECT);
 
1357
 
 
1358
        truth = new Mat(3, 3, CvType.CV_32F, new Scalar(0.00099945068));
 
1359
        assertMatEqual(truth, dst, EPS);
 
1360
    }
 
1361
 
 
1362
    public void testMatchShapes() {
 
1363
        Mat contour1 = new Mat(1, 4, CvType.CV_32FC2);
 
1364
        Mat contour2 = new Mat(1, 4, CvType.CV_32FC2);
 
1365
        contour1.put(0, 0, 1, 1, 5, 1, 4, 3, 6, 2);
 
1366
        contour2.put(0, 0, 1, 1, 6, 1, 4, 1, 2, 5);
 
1367
 
 
1368
        double distance = Imgproc.matchShapes(contour1, contour2, Imgproc.CV_CONTOURS_MATCH_I1, 1);
 
1369
 
 
1370
        assertEquals(2.81109697365334, distance, EPS);
 
1371
    }
 
1372
 
 
1373
    public void testMatchTemplate() {
 
1374
        Mat image = new Mat(imgprocSz, imgprocSz, CvType.CV_8U);
 
1375
        Mat templ = new Mat(imgprocSz, imgprocSz, CvType.CV_8U);
 
1376
        image.put(0, 0, 1, 2, 3, 4);
 
1377
        templ.put(0, 0, 5, 6, 7, 8);
 
1378
 
 
1379
        Imgproc.matchTemplate(image, templ, dst, Imgproc.TM_CCORR);
 
1380
 
 
1381
        truth = new Mat(1, 1, CvType.CV_32F, new Scalar(70));
 
1382
        assertMatEqual(truth, dst, EPS);
 
1383
 
 
1384
        Imgproc.matchTemplate(gray255, gray0, dst, Imgproc.TM_CCORR);
 
1385
 
 
1386
        truth = new Mat(1, 1, CvType.CV_32F, new Scalar(0));
 
1387
        assertMatEqual(truth, dst, EPS);
 
1388
    }
 
1389
 
 
1390
    public void testMedianBlur() {
 
1391
        Imgproc.medianBlur(gray255, dst, 5);
 
1392
        assertMatEqual(gray255, dst);
 
1393
 
 
1394
        Imgproc.medianBlur(gray2, dst, 3);
 
1395
        assertMatEqual(gray2, dst);
 
1396
        // TODO_: write better test
 
1397
    }
 
1398
 
 
1399
    public void testMinAreaRect() {
 
1400
        MatOfPoint2f points = new MatOfPoint2f(new Point(1, 1), new Point(5, 1), new Point(4, 3), new Point(6, 2));
 
1401
 
 
1402
        RotatedRect rrect = Imgproc.minAreaRect(points);
 
1403
 
 
1404
        assertEquals(new Size(2, 5), rrect.size);
 
1405
        assertEquals(-90., rrect.angle);
 
1406
        assertEquals(new Point(3.5, 2), rrect.center);
 
1407
    }
 
1408
 
 
1409
    public void testMinEnclosingCircle() {
 
1410
        MatOfPoint2f points = new MatOfPoint2f(new Point(0, 0), new Point(-1, 0), new Point(0, -1), new Point(1, 0), new Point(0, 1));
 
1411
        Point actualCenter = new Point();
 
1412
        float[] radius = new float[1];
 
1413
 
 
1414
        Imgproc.minEnclosingCircle(points, actualCenter, radius);
 
1415
 
 
1416
        assertEquals(new Point(0, 0), actualCenter);
 
1417
        assertEquals(1.03f, radius[0], EPS);
 
1418
    }
 
1419
 
 
1420
    public void testMomentsMat() {
 
1421
        fail("Not yet implemented");
 
1422
    }
 
1423
 
 
1424
    public void testMomentsMatBoolean() {
 
1425
        fail("Not yet implemented");
 
1426
    }
 
1427
 
 
1428
    public void testMorphologyExMatMatIntMat() {
 
1429
        Imgproc.morphologyEx(gray255, dst, Imgproc.MORPH_GRADIENT, gray0);
 
1430
 
 
1431
        assertMatEqual(gray0, dst);
 
1432
        // TODO_: write better test
 
1433
    }
 
1434
 
 
1435
    public void testMorphologyExMatMatIntMatPointInt() {
 
1436
        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_8U);
 
1437
 
 
1438
        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_8U, new Scalar(0));
 
1439
        Point point = new Point(0, 0);
 
1440
 
 
1441
        Imgproc.morphologyEx(src, dst, Imgproc.MORPH_CLOSE, kernel, point, 10);
 
1442
 
 
1443
        truth = Mat.eye(imgprocSz, imgprocSz, CvType.CV_8U);
 
1444
        assertMatEqual(truth, dst);
 
1445
        // TODO_: write better test
 
1446
    }
 
1447
 
 
1448
 
 
1449
    public void testMorphologyExMatMatIntMatPointIntIntScalar() {
 
1450
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_8U);
 
1451
        src.put(0, 0, 2, 1);
 
1452
        src.put(1, 0, 2, 1);
 
1453
 
 
1454
        Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_8U, new Scalar(1));
 
1455
        Point point = new Point(1, 1);
 
1456
        Scalar sc = new Scalar(3, 3);
 
1457
 
 
1458
        Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel, point, 10, Core.BORDER_REFLECT, sc);
 
1459
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_8U) {
 
1460
            {
 
1461
                put(0, 0, 1, 0);
 
1462
                put(1, 0, 1, 0);
 
1463
            }
 
1464
        };
 
1465
        assertMatEqual(truth, dst);
 
1466
        // TODO_: write better test
 
1467
    }
 
1468
 
 
1469
    public void testPointPolygonTest() {
 
1470
        MatOfPoint2f contour = new MatOfPoint2f(new Point(0, 0), new Point(1, 3), new Point(3, 4), new Point(4, 3), new Point(2, 1));
 
1471
        double sign1 = Imgproc.pointPolygonTest(contour, new Point(2, 2), false);
 
1472
        assertEquals(1.0, sign1);
 
1473
 
 
1474
        double sign2 = Imgproc.pointPolygonTest(contour, new Point(4, 4), true);
 
1475
        assertEquals(-Math.sqrt(0.5), sign2);
 
1476
    }
 
1477
 
 
1478
    public void testPreCornerDetectMatMatInt() {
 
1479
        Mat src = new Mat(4, 4, CvType.CV_32F, new Scalar(1));
 
1480
        int ksize = 3;
 
1481
 
 
1482
        Imgproc.preCornerDetect(src, dst, ksize);
 
1483
 
 
1484
        truth = new Mat(4, 4, CvType.CV_32F, new Scalar(0));
 
1485
        assertMatEqual(truth, dst, EPS);
 
1486
    }
 
1487
 
 
1488
    public void testPreCornerDetectMatMatIntInt() {
 
1489
        Mat src = new Mat(4, 4, CvType.CV_32F, new Scalar(1));
 
1490
        int ksize = 3;
 
1491
 
 
1492
        Imgproc.preCornerDetect(src, dst, ksize, Core.BORDER_REFLECT);
 
1493
 
 
1494
        truth = new Mat(4, 4, CvType.CV_32F, new Scalar(0));
 
1495
        assertMatEqual(truth, dst, EPS);
 
1496
        // TODO_: write better test
 
1497
    }
 
1498
 
 
1499
    public void testPyrDownMatMat() {
 
1500
        Mat src = new Mat(4, 4, CvType.CV_32F) {
 
1501
            {
 
1502
                put(0, 0, 2, 1, 4, 2);
 
1503
                put(1, 0, 3, 2, 6, 8);
 
1504
                put(2, 0, 4, 6, 8, 10);
 
1505
                put(3, 0, 12, 32, 6, 18);
 
1506
            }
 
1507
        };
 
1508
 
 
1509
        Imgproc.pyrDown(src, dst);
 
1510
 
 
1511
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F) {
 
1512
            {
 
1513
                put(0, 0, 2.78125, 4.609375);
 
1514
                put(1, 0, 8.546875, 8.8515625);
 
1515
            }
 
1516
        };
 
1517
        assertMatEqual(truth, dst, EPS);
 
1518
    }
 
1519
 
 
1520
    public void testPyrDownMatMatSize() {
 
1521
        Mat src = new Mat(4, 4, CvType.CV_32F) {
 
1522
            {
 
1523
                put(0, 0, 2, 1, 4, 2);
 
1524
                put(1, 0, 3, 2, 6, 8);
 
1525
                put(2, 0, 4, 6, 8, 10);
 
1526
                put(3, 0, 12, 32, 6, 18);
 
1527
            }
 
1528
        };
 
1529
        Size dstSize = new Size(2, 2);
 
1530
 
 
1531
        Imgproc.pyrDown(src, dst, dstSize);
 
1532
 
 
1533
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F) {
 
1534
            {
 
1535
                put(0, 0, 2.78125, 4.609375);
 
1536
                put(1, 0, 8.546875, 8.8515625);
 
1537
            }
 
1538
        };
 
1539
        assertMatEqual(truth, dst, EPS);
 
1540
        // TODO_: write better test
 
1541
    }
 
1542
 
 
1543
    public void testPyrMeanShiftFilteringMatMatDoubleDouble() {
 
1544
        Mat src = new Mat(matSize, matSize, CvType.CV_8UC3, new Scalar(0));
 
1545
 
 
1546
        Imgproc.pyrMeanShiftFiltering(src, dst, 10, 50);
 
1547
 
 
1548
        assertMatEqual(src, dst);
 
1549
        // TODO_: write better test
 
1550
    }
 
1551
 
 
1552
    public void testPyrMeanShiftFilteringMatMatDoubleDoubleInt() {
 
1553
        fail("Not yet implemented");
 
1554
    }
 
1555
 
 
1556
    public void testPyrMeanShiftFilteringMatMatDoubleDoubleIntTermCriteria() {
 
1557
        fail("Not yet implemented");
 
1558
    }
 
1559
 
 
1560
    public void testPyrUpMatMat() {
 
1561
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
 
1562
        src.put(0, 0, 2, 1);
 
1563
        src.put(1, 0, 3, 2);
 
1564
 
 
1565
        Imgproc.pyrUp(src, dst);
 
1566
 
 
1567
        truth = new Mat(4, 4, CvType.CV_32F) {
 
1568
            {
 
1569
                put(0, 0, 2,     1.75,  1.375, 1.25);
 
1570
                put(1, 0, 2.25,  2,     1.625, 1.5);
 
1571
                put(2, 0, 2.625, 2.375, 2,     1.875);
 
1572
                put(3, 0, 2.75,  2.5,   2.125, 2);
 
1573
            }
 
1574
        };
 
1575
        assertMatEqual(truth, dst, EPS);
 
1576
    }
 
1577
 
 
1578
    public void testPyrUpMatMatSize() {
 
1579
        fail("Not yet implemented");
 
1580
    }
 
1581
 
 
1582
    public void testRemapMatMatMatMatInt() {
 
1583
        fail("Not yet implemented");
 
1584
        // this test does something weird
 
1585
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
 
1586
        Mat map1 = new Mat(1, 3, CvType.CV_32FC1);
 
1587
        Mat map2 = new Mat(1, 3, CvType.CV_32FC1);
 
1588
 
 
1589
        map1.put(0, 0, 3, 6, 5);
 
1590
        map2.put(0, 0, 4, 8, 12);
 
1591
 
 
1592
        Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR);
 
1593
 
 
1594
        truth = new Mat(1, 3, CvType.CV_32F, new Scalar(0));
 
1595
        assertMatEqual(truth, dst, EPS);
 
1596
    }
 
1597
 
 
1598
    public void testRemapMatMatMatMatIntIntScalar() {
 
1599
        fail("Not yet implemented");
 
1600
        // this test does something weird
 
1601
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
 
1602
        Mat map1 = new Mat(1, 3, CvType.CV_32FC1);
 
1603
        Mat map2 = new Mat(1, 3, CvType.CV_32FC1);
 
1604
 
 
1605
        Scalar sc = new Scalar(0);
 
1606
 
 
1607
        map1.put(0, 0, 3, 6, 5, 0);
 
1608
        map2.put(0, 0, 4, 8, 12);
 
1609
 
 
1610
        truth = new Mat(1, 3, CvType.CV_32F, new Scalar(2));
 
1611
 
 
1612
        Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR, Core.BORDER_REFLECT, sc);
 
1613
        assertMatEqual(truth, dst, EPS);
 
1614
    }
 
1615
 
 
1616
    public void testResizeMatMatSize() {
 
1617
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_8UC1, new Scalar(1));
 
1618
        Size dsize = new Size(1, 1);
 
1619
 
 
1620
        Imgproc.resize(src, dst, dsize);
 
1621
 
 
1622
        truth = new Mat(1, 1, CvType.CV_8UC1, new Scalar(1));
 
1623
        assertMatEqual(truth, dst);
 
1624
    }
 
1625
 
 
1626
    public void testResizeMatMatSizeDoubleDoubleInt() {
 
1627
        Imgproc.resize(gray255, dst, new Size(2, 2), 0, 0, Imgproc.INTER_AREA);
 
1628
 
 
1629
        truth = new Mat(2, 2, CvType.CV_8UC1, new Scalar(255));
 
1630
        assertMatEqual(truth, dst);
 
1631
        // TODO_: write better test
 
1632
    }
 
1633
 
 
1634
    public void testScharrMatMatIntIntInt() {
 
1635
        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
 
1636
 
 
1637
        Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0);
 
1638
 
 
1639
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
 
1640
        assertMatEqual(truth, dst, EPS);
 
1641
    }
 
1642
 
 
1643
    public void testScharrMatMatIntIntIntDoubleDouble() {
 
1644
        Mat src = Mat.eye(imgprocSz, imgprocSz, CvType.CV_32F);
 
1645
 
 
1646
        Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0.001);
 
1647
 
 
1648
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0.001));
 
1649
        assertMatEqual(truth, dst, EPS);
 
1650
    }
 
1651
 
 
1652
    public void testScharrMatMatIntIntIntDoubleDoubleInt() {
 
1653
        Mat src = Mat.eye(3, 3, CvType.CV_32F);
 
1654
 
 
1655
        Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0, Core.BORDER_REFLECT);
 
1656
 
 
1657
        truth = new Mat(3, 3, CvType.CV_32F) {
 
1658
            {
 
1659
                put(0, 0, -15, -19.5, -4.5);
 
1660
                put(1, 0, 10.5, 0, -10.5);
 
1661
                put(2, 0, 4.5, 19.5, 15);
 
1662
            }
 
1663
        };
 
1664
        assertMatEqual(truth, dst, EPS);
 
1665
    }
 
1666
 
 
1667
    public void testSepFilter2DMatMatIntMatMat() {
 
1668
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(2));
 
1669
        Mat kernelX = new Mat(1, 3, CvType.CV_32FC1);
 
1670
        Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
 
1671
        kernelX.put(0, 0, 4, 3, 7);
 
1672
        kernelY.put(0, 0, 9, 4, 2);
 
1673
 
 
1674
        Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY);
 
1675
 
 
1676
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(420));
 
1677
        assertMatEqual(truth, dst, EPS);
 
1678
    }
 
1679
 
 
1680
    public void testSepFilter2DMatMatIntMatMatPointDouble() {
 
1681
        Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1, new Scalar(2));
 
1682
        Mat kernelX = new Mat(1, 3, CvType.CV_32FC1);
 
1683
        kernelX.put(0, 0, 2, 2, 2);
 
1684
        Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
 
1685
        kernelY.put(0, 0, 1, 1, 1);
 
1686
 
 
1687
        Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY, anchorPoint, weakEPS);
 
1688
 
 
1689
        truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(36 + weakEPS));
 
1690
        assertMatEqual(truth, dst, EPS);
 
1691
    }
 
1692
 
 
1693
    public void testSepFilter2DMatMatIntMatMatPointDoubleInt() {
 
1694
        Mat kernelX = new Mat(1, 3, CvType.CV_32FC1);
 
1695
        kernelX.put(0, 0, 2, 2, 2);
 
1696
 
 
1697
        Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
 
1698
        kernelY.put(0, 0, 1, 1, 1);
 
1699
 
 
1700
        Imgproc.sepFilter2D(gray0, dst, CvType.CV_32F, kernelX, kernelY, anchorPoint, weakEPS, Core.BORDER_REFLECT);
 
1701
 
 
1702
        truth = new Mat(10, 10, CvType.CV_32F, new Scalar(weakEPS));
 
1703
        assertMatEqual(truth, dst, EPS);
 
1704
        // TODO_: write better test
 
1705
    }
 
1706
 
 
1707
    public void testSobelMatMatIntIntInt() {
 
1708
        Imgproc.Sobel(gray255, dst, CvType.CV_8U, 1, 0);
 
1709
 
 
1710
        assertMatEqual(gray0, dst);
 
1711
    }
 
1712
 
 
1713
    public void testSobelMatMatIntIntIntIntDoubleDouble() {
 
1714
        Imgproc.Sobel(gray255, dst, CvType.CV_8U, 1, 0, 3, 2, 0.001);
 
1715
        assertMatEqual(gray0, dst);
 
1716
        // TODO_: write better test
 
1717
    }
 
1718
 
 
1719
    public void testSobelMatMatIntIntIntIntDoubleDoubleInt() {
 
1720
        Mat src = new Mat(3, 3, CvType.CV_32F) {
 
1721
            {
 
1722
                put(0, 0, 2, 0, 1);
 
1723
                put(1, 0, 6, 4, 3);
 
1724
                put(2, 0, 1, 0, 2);
 
1725
            }
 
1726
        };
 
1727
 
 
1728
        Imgproc.Sobel(src, dst, CvType.CV_32F, 1, 0, 3, 2, 0, Core.BORDER_REPLICATE);
 
1729
 
 
1730
        truth = new Mat(3, 3, CvType.CV_32F) {
 
1731
            {
 
1732
                put(0, 0, -16, -12, 4);
 
1733
                put(1, 0, -14, -12, 2);
 
1734
                put(2, 0, -10, 0, 10);
 
1735
            }
 
1736
        };
 
1737
        assertMatEqual(truth, dst, EPS);
 
1738
    }
 
1739
 
 
1740
    public void testThreshold() {
 
1741
        Imgproc.threshold(makeMask(gray0.clone(), 10), dst, 5, 255, Imgproc.THRESH_TRUNC);
 
1742
        assertMatEqual(makeMask(gray0.clone(), 5), dst);
 
1743
 
 
1744
        Imgproc.threshold(makeMask(gray2.clone(), 10), dst, 1, 255, Imgproc.THRESH_BINARY);
 
1745
        assertMatEqual(gray255, dst);
 
1746
 
 
1747
        Imgproc.threshold(makeMask(gray2.clone(), 10), dst, 3, 255, Imgproc.THRESH_BINARY_INV);
 
1748
        assertMatEqual(makeMask(gray255.clone(), 0), dst);
 
1749
    }
 
1750
 
 
1751
    public void testUndistortMatMatMatMat() {
 
1752
        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
 
1753
        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
 
1754
            {
 
1755
                put(0, 0, 1, 0, 1);
 
1756
                put(1, 0, 0, 1, 2);
 
1757
                put(2, 0, 0, 0, 1);
 
1758
            }
 
1759
        };
 
1760
        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
 
1761
            {
 
1762
                put(0, 0, 1, 3, 2, 4);
 
1763
            }
 
1764
        };
 
1765
 
 
1766
        Imgproc.undistort(src, dst, cameraMatrix, distCoeffs);
 
1767
 
 
1768
        truth = new Mat(3, 3, CvType.CV_32F) {
 
1769
            {
 
1770
                put(0, 0, 0, 0, 0);
 
1771
                put(1, 0, 0, 0, 0);
 
1772
                put(2, 0, 0, 3, 0);
 
1773
            }
 
1774
        };
 
1775
        assertMatEqual(truth, dst, EPS);
 
1776
    }
 
1777
 
 
1778
    public void testUndistortMatMatMatMatMat() {
 
1779
        Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
 
1780
        Mat cameraMatrix = new Mat(3, 3, CvType.CV_32F) {
 
1781
            {
 
1782
                put(0, 0, 1, 0, 1);
 
1783
                put(1, 0, 0, 1, 2);
 
1784
                put(2, 0, 0, 0, 1);
 
1785
            }
 
1786
        };
 
1787
        Mat distCoeffs = new Mat(1, 4, CvType.CV_32F) {
 
1788
            {
 
1789
                put(0, 0, 2, 1, 4, 5);
 
1790
            }
 
1791
        };
 
1792
        Mat newCameraMatrix = new Mat(3, 3, CvType.CV_32F, new Scalar(1));
 
1793
 
 
1794
        Imgproc.undistort(src, dst, cameraMatrix, distCoeffs, newCameraMatrix);
 
1795
 
 
1796
        truth = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
 
1797
        assertMatEqual(truth, dst, EPS);
 
1798
    }
 
1799
 
 
1800
    //undistortPoints(List<Point> src, List<Point> dst, Mat cameraMatrix, Mat distCoeffs)
 
1801
    public void testUndistortPointsListOfPointListOfPointMatMat() {
 
1802
        MatOfPoint2f src = new MatOfPoint2f(new Point(1, 2), new Point(3, 4), new Point(-1, -1));
 
1803
        MatOfPoint2f dst = new MatOfPoint2f();
 
1804
        Mat cameraMatrix = Mat.eye(3, 3, CvType.CV_64FC1);
 
1805
        Mat distCoeffs = new Mat(8, 1, CvType.CV_64FC1, new Scalar(0));
 
1806
 
 
1807
        Imgproc.undistortPoints(src, dst, cameraMatrix, distCoeffs);
 
1808
 
 
1809
        assertEquals(src.size(), dst.size());
 
1810
        for(int i=0; i<src.toList().size(); i++) {
 
1811
            //Log.d("UndistortPoints", "s="+src.get(i)+", d="+dst.get(i));
 
1812
            assertTrue(src.toList().get(i).equals(dst.toList().get(i)));
 
1813
        }
 
1814
    }
 
1815
 
 
1816
 
 
1817
    public void testWarpAffineMatMatMatSize() {
 
1818
        Mat src = new Mat(3, 3, CvType.CV_32F) {
 
1819
            {
 
1820
                put(0, 0, 2, 0, 1);
 
1821
                put(1, 0, 6, 4, 3);
 
1822
                put(2, 0, 1, 0, 2);
 
1823
            }
 
1824
        };
 
1825
        Mat M = new Mat(2, 3, CvType.CV_32F) {
 
1826
            {
 
1827
                put(0, 0, 1, 0, 1);
 
1828
                put(1, 0, 0, 1, 1);
 
1829
            }
 
1830
        };
 
1831
 
 
1832
        Imgproc.warpAffine(src, dst, M, new Size(3, 3));
 
1833
 
 
1834
        truth = new Mat(3, 3, CvType.CV_32F) {
 
1835
            {
 
1836
                put(0, 0, 0, 0, 0);
 
1837
                put(1, 0, 0, 2, 0);
 
1838
                put(2, 0, 0, 6, 4);
 
1839
            }
 
1840
        };
 
1841
        assertMatEqual(truth, dst, EPS);
 
1842
    }
 
1843
 
 
1844
    public void testWarpAffineMatMatMatSizeInt() {
 
1845
        Mat src = new Mat(3, 3, CvType.CV_32F) {
 
1846
            {
 
1847
                put(0, 0, 2, 4, 1);
 
1848
                put(1, 0, 6, 4, 3);
 
1849
                put(2, 0, 0, 2, 2);
 
1850
            }
 
1851
        };
 
1852
        Mat M = new Mat(2, 3, CvType.CV_32F) {
 
1853
            {
 
1854
                put(0, 0, 1, 0, 0);
 
1855
                put(1, 0, 0, 0, 1);
 
1856
            }
 
1857
        };
 
1858
 
 
1859
        Imgproc.warpAffine(src, dst, M, new Size(2, 2), Imgproc.WARP_INVERSE_MAP);
 
1860
 
 
1861
        truth = new Mat(2, 2, CvType.CV_32F) {
 
1862
            {
 
1863
                put(0, 0, 6, 4);
 
1864
                put(1, 0, 6, 4);
 
1865
            }
 
1866
        };
 
1867
        assertMatEqual(truth, dst, EPS);
 
1868
    }
 
1869
 
 
1870
    public void testWarpAffineMatMatMatSizeIntInt() {
 
1871
        fail("Not yet implemented");
 
1872
    }
 
1873
 
 
1874
    public void testWarpAffineMatMatMatSizeIntIntScalar() {
 
1875
        fail("Not yet implemented");
 
1876
    }
 
1877
 
 
1878
    public void testWarpPerspectiveMatMatMatSize() {
 
1879
        Mat src = new Mat(3, 3, CvType.CV_32F) {
 
1880
            {
 
1881
                put(0, 0, 2, 4, 1);
 
1882
                put(1, 0, 0, 4, 5);
 
1883
                put(2, 0, 1, 2, 2);
 
1884
            }
 
1885
        };
 
1886
        Mat M = new Mat(3, 3, CvType.CV_32F) {
 
1887
            {
 
1888
                put(0, 0, 1, 0, 1);
 
1889
                put(1, 0, 0, 1, 1);
 
1890
                put(2, 0, 0, 0, 1);
 
1891
            }
 
1892
        };
 
1893
 
 
1894
        Imgproc.warpPerspective(src, dst, M, new Size(3, 3));
 
1895
 
 
1896
        truth = new Mat(3, 3, CvType.CV_32F) {
 
1897
            {
 
1898
                put(0, 0, 0, 0, 0);
 
1899
                put(1, 0, 0, 2, 4);
 
1900
                put(2, 0, 0, 0, 4);
 
1901
            }
 
1902
        };
 
1903
        assertMatEqual(truth, dst, EPS);
 
1904
    }
 
1905
 
 
1906
    public void testWarpPerspectiveMatMatMatSizeInt() {
 
1907
        fail("Not yet implemented");
 
1908
    }
 
1909
 
 
1910
    public void testWarpPerspectiveMatMatMatSizeIntInt() {
 
1911
        fail("Not yet implemented");
 
1912
    }
 
1913
 
 
1914
    public void testWarpPerspectiveMatMatMatSizeIntIntScalar() {
 
1915
        fail("Not yet implemented");
 
1916
    }
 
1917
 
 
1918
    public void testWatershed() {
 
1919
        Mat image = Mat.eye(4, 4, CvType.CV_8UC(3));
 
1920
        Mat markers = new Mat(4, 4, CvType.CV_32SC1, new Scalar(0));
 
1921
 
 
1922
        Imgproc.watershed(image, markers);
 
1923
 
 
1924
        truth = new Mat(4, 4, CvType.CV_32SC1) {
 
1925
            {
 
1926
                put(0, 0, -1, -1, -1, -1);
 
1927
                put(1, 0, -1, 0, 0, -1);
 
1928
                put(2, 0, -1, 0, 0, -1);
 
1929
                put(3, 0, -1, -1, -1, -1);
 
1930
            }
 
1931
        };
 
1932
        assertMatEqual(truth, markers);
 
1933
    }
 
1934
 
 
1935
    public void testGetTextSize() {
 
1936
        String text = "Android all the way";
 
1937
        double fontScale = 2;
 
1938
        int thickness = 3;
 
1939
        int baseLine[] = new int[1];
 
1940
 
 
1941
        Imgproc.getTextSize(text, Core.FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale, thickness, null);
 
1942
        Size res = Imgproc.getTextSize(text, Core.FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale, thickness, baseLine);
 
1943
 
 
1944
        assertEquals(543.0, res.width);
 
1945
        assertEquals(44.0, res.height);
 
1946
        assertEquals(20, baseLine[0]);
 
1947
    }
 
1948
 
 
1949
    public void testCircleMatPointIntScalar() {
 
1950
        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
 
1951
        int radius = Math.min(gray0.cols() / 4, gray0.rows() / 4);
 
1952
        Scalar color = new Scalar(128);
 
1953
 
 
1954
        Imgproc.circle(gray0, center, radius, color);
 
1955
 
 
1956
        assertTrue(0 != Core.countNonZero(gray0));
 
1957
    }
 
1958
 
 
1959
    public void testCircleMatPointIntScalarInt() {
 
1960
        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
 
1961
        int radius = Math.min(gray0.cols() / 4, gray0.rows() / 4);
 
1962
        Scalar color = new Scalar(128);
 
1963
 
 
1964
        Imgproc.circle(gray0, center, radius, color, Core.FILLED);
 
1965
 
 
1966
        assertTrue(0 != Core.countNonZero(gray0));
 
1967
    }
 
1968
 
 
1969
    public void testCircleMatPointIntScalarIntIntInt() {
 
1970
        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
 
1971
        Point center2 = new Point(gray0.cols(), gray0.rows());
 
1972
        int radius = Math.min(gray0.cols() / 4, gray0.rows() / 4);
 
1973
        Scalar color128 = new Scalar(128);
 
1974
        Scalar color0 = new Scalar(0);
 
1975
 
 
1976
        Imgproc.circle(gray0, center2, radius * 2, color128, 2, Imgproc.LINE_4, 1/*
 
1977
                                                                            * Number
 
1978
                                                                            * of
 
1979
                                                                            * fractional
 
1980
                                                                            * bits
 
1981
                                                                            */);
 
1982
        assertFalse(0 == Core.countNonZero(gray0));
 
1983
 
 
1984
        Imgproc.circle(gray0, center, radius, color0, 2, Imgproc.LINE_4, 0);
 
1985
 
 
1986
        assertTrue(0 == Core.countNonZero(gray0));
 
1987
    }
 
1988
 
 
1989
    public void testClipLine() {
 
1990
        Rect r = new Rect(10, 10, 10, 10);
 
1991
        Point pt1 = new Point(5.0, 15.0);
 
1992
        Point pt2 = new Point(25.0, 15.0);
 
1993
 
 
1994
        assertTrue(Imgproc.clipLine(r, pt1, pt2));
 
1995
 
 
1996
        Point pt1Clipped = new Point(10.0, 15.0);
 
1997
        Point pt2Clipped = new Point(19.0, 15.0);
 
1998
        assertEquals(pt1Clipped, pt1);
 
1999
        assertEquals(pt2Clipped, pt2);
 
2000
 
 
2001
        pt1 = new Point(5.0, 5.0);
 
2002
        pt2 = new Point(25.0, 5.0);
 
2003
        pt1Clipped = new Point(5.0, 5.0);
 
2004
        pt2Clipped = new Point(25.0, 5.0);
 
2005
 
 
2006
        assertFalse(Imgproc.clipLine(r, pt1, pt2));
 
2007
 
 
2008
        assertEquals(pt1Clipped, pt1);
 
2009
        assertEquals(pt2Clipped, pt2);
 
2010
    }
 
2011
 
 
2012
    public void testEllipse2Poly() {
 
2013
        Point center = new Point(4, 4);
 
2014
        Size axes = new Size(2, 2);
 
2015
        int angle = 30;
 
2016
        int arcStart = 30;
 
2017
        int arcEnd = 60;
 
2018
        int delta = 2;
 
2019
        MatOfPoint pts = new MatOfPoint();
 
2020
 
 
2021
        Imgproc.ellipse2Poly(center, axes, angle, arcStart, arcEnd, delta, pts);
 
2022
 
 
2023
        Point truth[] = {
 
2024
                new Point(5, 6),
 
2025
                new Point(4, 6)
 
2026
        };
 
2027
        assertArrayPointsEquals(truth, pts.toArray(), EPS);
 
2028
    }
 
2029
 
 
2030
    public void testEllipseMatPointSizeDoubleDoubleDoubleScalar() {
 
2031
        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
 
2032
        Size axes = new Size(2, 2);
 
2033
        double angle = 30, startAngle = 60, endAngle = 90;
 
2034
 
 
2035
        Imgproc.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite);
 
2036
 
 
2037
        assertTrue(0 != Core.countNonZero(gray0));
 
2038
    }
 
2039
 
 
2040
    public void testEllipseMatPointSizeDoubleDoubleDoubleScalarInt() {
 
2041
        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
 
2042
        Size axes = new Size(2, 2);
 
2043
        double angle = 30, startAngle = 60, endAngle = 90;
 
2044
 
 
2045
        Imgproc.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED);
 
2046
 
 
2047
        assertTrue(0 != Core.countNonZero(gray0));
 
2048
    }
 
2049
 
 
2050
    public void testEllipseMatPointSizeDoubleDoubleDoubleScalarIntIntInt() {
 
2051
        Point center = new Point(gray0.cols() / 2, gray0.rows() / 2);
 
2052
        Size axes = new Size(2, 2);
 
2053
        Point center2 = new Point(gray0.cols(), gray0.rows());
 
2054
        Size axes2 = new Size(4, 4);
 
2055
        double angle = 30, startAngle = 0, endAngle = 30;
 
2056
 
 
2057
        Imgproc.ellipse(gray0, center, axes, angle, startAngle, endAngle, colorWhite, Core.FILLED, Imgproc.LINE_4, 0);
 
2058
 
 
2059
        assertTrue(0 != Core.countNonZero(gray0));
 
2060
 
 
2061
        Imgproc.ellipse(gray0, center2, axes2, angle, startAngle, endAngle, colorBlack, Core.FILLED, Imgproc.LINE_4, 1);
 
2062
 
 
2063
        assertEquals(0, Core.countNonZero(gray0));
 
2064
    }
 
2065
 
 
2066
    public void testEllipseMatRotatedRectScalar() {
 
2067
        int matSize = 10;
 
2068
        Mat gray0 = Mat.zeros(matSize, matSize, CvType.CV_8U);
 
2069
        Point center = new Point(matSize / 2, matSize / 2);
 
2070
        Size size = new Size(matSize / 4, matSize / 2);
 
2071
        RotatedRect box = new RotatedRect(center, size, 45);
 
2072
 
 
2073
        Imgproc.ellipse(gray0, box, new Scalar(1));
 
2074
 
 
2075
        final byte[] truth = new byte[] {
 
2076
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
2077
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
2078
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
2079
                0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
 
2080
                0, 0, 0, 0, 1, 1, 0, 1, 0, 0,
 
2081
                0, 0, 0, 0, 1, 0, 1, 0, 0, 0,
 
2082
                0, 0, 0, 1, 0, 1, 1, 0, 0, 0,
 
2083
                0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
 
2084
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
2085
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
2086
 
 
2087
        assertMatEqual(new Mat(matSize, matSize, CvType.CV_8U) {
 
2088
            {
 
2089
                put(0, 0, truth);
 
2090
            }
 
2091
        }, gray0);
 
2092
    }
 
2093
 
 
2094
    public void testEllipseMatRotatedRectScalarInt() {
 
2095
        Point center = new Point(matSize / 2, matSize / 2);
 
2096
        Size size = new Size(matSize / 4, matSize / 2);
 
2097
        RotatedRect box = new RotatedRect(center, size, 45);
 
2098
 
 
2099
        Imgproc.ellipse(gray0, box, new Scalar(1), Core.FILLED);
 
2100
        Imgproc.ellipse(gray0, box, new Scalar(0));
 
2101
 
 
2102
        assertTrue(0 < Core.countNonZero(gray0));
 
2103
    }
 
2104
 
 
2105
    public void testEllipseMatRotatedRectScalarIntInt() {
 
2106
        Point center = new Point(matSize / 2, matSize / 2);
 
2107
        Size size = new Size(2, matSize * 2 / 3);
 
2108
        RotatedRect box = new RotatedRect(center, size, 20);
 
2109
 
 
2110
        Imgproc.ellipse(gray0, box, new Scalar(9), 1, Imgproc.LINE_AA);
 
2111
        Imgproc.ellipse(gray0, box, new Scalar(0), 1, Imgproc.LINE_4);
 
2112
 
 
2113
        assertTrue(0 < Core.countNonZero(gray0));
 
2114
    }
 
2115
 
 
2116
    public void testPolylinesMatListOfListOfPointBooleanScalar() {
 
2117
        Mat img = gray0;
 
2118
        List<MatOfPoint> polyline = new ArrayList<MatOfPoint>();
 
2119
        polyline.add(new MatOfPoint(new Point(1, 1), new Point(7, 1), new Point(7, 6), new Point(1, 6)));
 
2120
 
 
2121
        Imgproc.polylines(img, polyline, true, new Scalar(100));
 
2122
 
 
2123
        assertEquals(22, Core.countNonZero(img));
 
2124
 
 
2125
        Imgproc.polylines(img, polyline, false, new Scalar(0));
 
2126
 
 
2127
        assertEquals(4, Core.countNonZero(img));
 
2128
    }
 
2129
 
 
2130
    public void testPolylinesMatListOfListOfPointBooleanScalarInt() {
 
2131
        Mat img = gray0;
 
2132
        List<MatOfPoint> polyline = new ArrayList<MatOfPoint>();
 
2133
        polyline.add(new MatOfPoint(new Point(1, 1), new Point(7, 1), new Point(7, 6), new Point(1, 6)));
 
2134
 
 
2135
        Imgproc.polylines(img, polyline, true, new Scalar(100), 2);
 
2136
 
 
2137
        assertEquals(62, Core.countNonZero(img));
 
2138
    }
 
2139
 
 
2140
    public void testPolylinesMatListOfListOfPointBooleanScalarIntIntInt() {
 
2141
        Mat img = gray0;
 
2142
        List<MatOfPoint> polyline1 = new ArrayList<MatOfPoint>();
 
2143
        polyline1.add(new MatOfPoint(new Point(1, 1), new Point(7, 1), new Point(7, 6), new Point(1, 6)));
 
2144
        List<MatOfPoint> polyline2 = new ArrayList<MatOfPoint>();
 
2145
        polyline2.add(new MatOfPoint(new Point(2, 2), new Point(14, 2), new Point(14, 12), new Point(2, 12)));
 
2146
 
 
2147
        Imgproc.polylines(img, polyline1, true, new Scalar(100), 2, Imgproc.LINE_8, 0);
 
2148
 
 
2149
        assertTrue(Core.countNonZero(img) > 0);
 
2150
 
 
2151
        Imgproc.polylines(img, polyline2, true, new Scalar(0), 2, Imgproc.LINE_8, 1);
 
2152
 
 
2153
        assertEquals(0, Core.countNonZero(img));
 
2154
    }
 
2155
 
 
2156
    public void testPutTextMatStringPointIntDoubleScalar() {
 
2157
        String text = "Hello World";
 
2158
        Size labelSize = new Size(175, 22);
 
2159
        Mat img = new Mat(20 + (int) labelSize.height, 20 + (int) labelSize.width, CvType.CV_8U, colorBlack);
 
2160
        Point origin = new Point(10, labelSize.height + 10);
 
2161
 
 
2162
        Imgproc.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorWhite);
 
2163
 
 
2164
        assertTrue(Core.countNonZero(img) > 0);
 
2165
        // check that border is not corrupted
 
2166
        Imgproc.rectangle(img, new Point(11, 11), new Point(labelSize.width + 10, labelSize.height + 10), colorBlack, Core.FILLED);
 
2167
        assertEquals(0, Core.countNonZero(img));
 
2168
    }
 
2169
 
 
2170
    public void testPutTextMatStringPointIntDoubleScalarInt() {
 
2171
        String text = "Hello World";
 
2172
        Size labelSize = new Size(176, 22);
 
2173
        Mat img = new Mat(20 + (int) labelSize.height, 20 + (int) labelSize.width, CvType.CV_8U, colorBlack);
 
2174
        Point origin = new Point(10, labelSize.height + 10);
 
2175
 
 
2176
        Imgproc.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorWhite, 2);
 
2177
 
 
2178
        assertTrue(Core.countNonZero(img) > 0);
 
2179
        // check that border is not corrupted
 
2180
        Imgproc.rectangle(img, new Point(10, 10), new Point(labelSize.width + 10 + 1, labelSize.height + 10 + 1), colorBlack, Core.FILLED);
 
2181
        assertEquals(0, Core.countNonZero(img));
 
2182
    }
 
2183
 
 
2184
    public void testPutTextMatStringPointIntDoubleScalarIntIntBoolean() {
 
2185
        String text = "Hello World";
 
2186
        Size labelSize = new Size(175, 22);
 
2187
 
 
2188
        Mat img = new Mat(20 + (int) labelSize.height, 20 + (int) labelSize.width, CvType.CV_8U, colorBlack);
 
2189
        Point origin = new Point(10, 10);
 
2190
 
 
2191
        Imgproc.putText(img, text, origin, Core.FONT_HERSHEY_SIMPLEX, 1.0, colorWhite, 1, Imgproc.LINE_8, true);
 
2192
 
 
2193
        assertTrue(Core.countNonZero(img) > 0);
 
2194
        // check that border is not corrupted
 
2195
        Imgproc.rectangle(img, new Point(10, 10), new Point(labelSize.width + 9, labelSize.height + 9), colorBlack, Core.FILLED);
 
2196
        assertEquals(0, Core.countNonZero(img));
 
2197
    }
 
2198
}