merged 2.4 into trunk
This commit is contained in:
@@ -23,10 +23,12 @@ public class UtilsTest extends OpenCVTestCase {
|
||||
Bitmap bmp16 = BitmapFactory.decodeFile(OpenCVTestRunner.LENA_PATH, opt16);
|
||||
Mat m16 = new Mat();
|
||||
Utils.bitmapToMat(bmp16, m16);
|
||||
assertTrue(m16.rows() == 512 && m16.cols() == 512 && m16.type() == CvType.CV_8UC4);
|
||||
|
||||
BitmapFactory.Options opt32 = new BitmapFactory.Options();
|
||||
/*BitmapFactory.Options opt32 = new BitmapFactory.Options();
|
||||
opt32.inPreferredConfig = Bitmap.Config.ARGB_8888;
|
||||
Bitmap bmp32 = BitmapFactory.decodeFile(OpenCVTestRunner.LENA_PATH, opt32);
|
||||
Bitmap bmp32 = BitmapFactory.decodeFile(OpenCVTestRunner.LENA_PATH, opt32);*/
|
||||
Bitmap bmp32 = bmp16.copy(Bitmap.Config.ARGB_8888, false);
|
||||
Mat m32 = new Mat();
|
||||
Utils.bitmapToMat(bmp32, m32);
|
||||
|
||||
@@ -34,6 +36,7 @@ public class UtilsTest extends OpenCVTestCase {
|
||||
|
||||
double maxDiff = Core.norm(m16, m32, Core.NORM_INF);
|
||||
Log.d("Bmp->Mat", "bmp16->Mat vs bmp32->Mat diff = " + maxDiff);
|
||||
|
||||
assertTrue(maxDiff <= 8 /* 8 == 2^8 / 2^5 */);
|
||||
}
|
||||
|
||||
|
@@ -4,6 +4,7 @@ import org.opencv.calib3d.Calib3d;
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.MatOfDouble;
|
||||
import org.opencv.core.MatOfPoint2f;
|
||||
import org.opencv.core.MatOfPoint3f;
|
||||
import org.opencv.core.Point;
|
||||
@@ -174,15 +175,17 @@ public class Calib3dTest extends OpenCVTestCase {
|
||||
|
||||
public void testFindChessboardCornersMatSizeMat() {
|
||||
Size patternSize = new Size(9, 6);
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, dst);
|
||||
assertTrue(!dst.empty());
|
||||
MatOfPoint2f corners = new MatOfPoint2f();
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, corners);
|
||||
assertTrue(!corners.empty());
|
||||
}
|
||||
|
||||
public void testFindChessboardCornersMatSizeMatInt() {
|
||||
Size patternSize = new Size(9, 6);
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, dst, Calib3d.CALIB_CB_ADAPTIVE_THRESH + Calib3d.CALIB_CB_NORMALIZE_IMAGE
|
||||
MatOfPoint2f corners = new MatOfPoint2f();
|
||||
Calib3d.findChessboardCorners(grayChess, patternSize, corners, Calib3d.CALIB_CB_ADAPTIVE_THRESH + Calib3d.CALIB_CB_NORMALIZE_IMAGE
|
||||
+ Calib3d.CALIB_CB_FAST_CHECK);
|
||||
assertTrue(!dst.empty());
|
||||
assertTrue(!corners.empty());
|
||||
}
|
||||
|
||||
public void testFindCirclesGridDefaultMatSizeMat() {
|
||||
@@ -515,7 +518,7 @@ public class Calib3dTest extends OpenCVTestCase {
|
||||
|
||||
Mat rvec = new Mat();
|
||||
Mat tvec = new Mat();
|
||||
Calib3d.solvePnP(points3d, points2d, intrinsics, new Mat(), rvec, tvec);
|
||||
Calib3d.solvePnP(points3d, points2d, intrinsics, new MatOfDouble(), rvec, tvec);
|
||||
|
||||
Mat truth_rvec = new Mat(3, 1, CvType.CV_64F);
|
||||
truth_rvec.put(0, 0, 0, Math.PI / 2, 0);
|
||||
|
@@ -1284,14 +1284,14 @@ public class CoreTest extends OpenCVTestCase {
|
||||
rgba0.setTo(new Scalar(10, 20, 30, 40));
|
||||
List<Mat> src = Arrays.asList(rgba0);
|
||||
List<Mat> dst = Arrays.asList(gray3, gray2, gray1, gray0, getMat(CvType.CV_8UC3, 0, 0, 0));
|
||||
MatOfInt fromTo = new MatOfInt(1, new int[]
|
||||
{ 3, 0,
|
||||
MatOfInt fromTo = new MatOfInt(
|
||||
3, 0,
|
||||
3, 1,
|
||||
2, 2,
|
||||
0, 3,
|
||||
2, 4,
|
||||
1, 5,
|
||||
0, 6 }
|
||||
0, 6
|
||||
);
|
||||
|
||||
Core.mixChannels(src, dst, fromTo);
|
||||
|
@@ -1,5 +1,7 @@
|
||||
package org.opencv.test.core;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
import org.opencv.core.Core;
|
||||
import org.opencv.core.CvException;
|
||||
import org.opencv.core.CvType;
|
||||
@@ -11,8 +13,6 @@ import org.opencv.core.Scalar;
|
||||
import org.opencv.core.Size;
|
||||
import org.opencv.test.OpenCVTestCase;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
public class MatTest extends OpenCVTestCase {
|
||||
|
||||
public void testAdjustROI() {
|
||||
@@ -272,21 +272,72 @@ public class MatTest extends OpenCVTestCase {
|
||||
assertEquals(5, Core.countNonZero(eye));
|
||||
|
||||
}
|
||||
|
||||
public Mat getTestMat(int size, int type) {
|
||||
Mat m = new Mat(size, size, type);
|
||||
final int ch = CvType.channels(type);
|
||||
double buff[] = new double[size*size * ch];
|
||||
for(int i=0; i<size; i++)
|
||||
for(int j=0; j<size; j++)
|
||||
for(int k=0; k<ch; k++) {
|
||||
buff[i*size*ch + j*ch + k] = 100*i + 10*j + k;
|
||||
}
|
||||
m.put(0, 0, buff);
|
||||
return m;
|
||||
}
|
||||
|
||||
public void testGetIntInt() {
|
||||
Mat src = new Mat(3, 3, CvType.CV_8U, new Scalar(2));
|
||||
double[] actualArray = src.get(1, 1);
|
||||
public void testGetIntInt_8U() {
|
||||
Mat m = getTestMat(5, CvType.CV_8UC2);
|
||||
|
||||
assertTrue(Arrays.equals(new double[] { 2 }, actualArray));
|
||||
// whole Mat
|
||||
assertTrue(Arrays.equals(new double[] {0, 1}, m.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {240, 241}, m.get(2, 4)));
|
||||
assertTrue(Arrays.equals(new double[] {255, 255}, m.get(4, 4)));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
assertTrue(Arrays.equals(new double[] {230, 231}, sm.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {255, 255}, sm.get(1, 1)));
|
||||
}
|
||||
|
||||
public void testGetIntInt_32S() {
|
||||
Mat m = getTestMat(5, CvType.CV_32SC3);
|
||||
|
||||
// whole Mat
|
||||
assertTrue(Arrays.equals(new double[] {0, 1, 2}, m.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {240, 241, 242}, m.get(2, 4)));
|
||||
assertTrue(Arrays.equals(new double[] {440, 441, 442}, m.get(4, 4)));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
assertTrue(Arrays.equals(new double[] {230, 231, 232}, sm.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {340, 341, 342}, sm.get(1, 1)));
|
||||
}
|
||||
|
||||
public void testGetIntInt_64F() {
|
||||
Mat m = getTestMat(5, CvType.CV_64FC1);
|
||||
|
||||
// whole Mat
|
||||
assertTrue(Arrays.equals(new double[] {0}, m.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {240}, m.get(2, 4)));
|
||||
assertTrue(Arrays.equals(new double[] {440}, m.get(4, 4)));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
assertTrue(Arrays.equals(new double[] {230}, sm.get(0, 0)));
|
||||
assertTrue(Arrays.equals(new double[] {340}, sm.get(1, 1)));
|
||||
}
|
||||
|
||||
public void testGetIntIntByteArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));
|
||||
Mat m = getTestMat(5, CvType.CV_8UC3);
|
||||
byte[] goodData = new byte[9];
|
||||
byte[] badData = new byte[7];
|
||||
m.get(1, 1, goodData);
|
||||
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, goodData);
|
||||
|
||||
assertTrue(Arrays.equals(new byte[] { 1, 2, 3, 1, 2, 3, 1, 2, 3 }, goodData));
|
||||
assertEquals(9, bytesNum);
|
||||
assertTrue(Arrays.equals(new byte[] { 110, 111, 112, 120, 121, 122, (byte) 130, (byte) 131, (byte) 132 }, goodData));
|
||||
|
||||
try {
|
||||
m.get(2, 2, badData);
|
||||
@@ -294,38 +345,105 @@ public class MatTest extends OpenCVTestCase {
|
||||
} catch (UnsupportedOperationException e) {
|
||||
// expected
|
||||
}
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
byte buff00[] = new byte[3];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(3, bytesNum);
|
||||
assertTrue(Arrays.equals(new byte[] {(byte) 230, (byte) 231, (byte) 232}, buff00));
|
||||
byte buff11[] = new byte[3];
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(3, bytesNum);
|
||||
assertTrue(Arrays.equals(new byte[] {(byte) 255, (byte) 255, (byte) 255}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntDoubleArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_64F);
|
||||
double[] doubleArray = { 1.0, 2.0, 3.0 };
|
||||
Mat m = getTestMat(5, CvType.CV_64F);
|
||||
double buff[] = new double[4];
|
||||
|
||||
int numOfBytes = src.get(0, 0, doubleArray);
|
||||
assertEquals(24, numOfBytes);
|
||||
}
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
assertEquals(32, bytesNum);
|
||||
assertTrue(Arrays.equals(new double[] { 110, 120, 130, 140 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
double buff00[] = new double[2];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(16, bytesNum);
|
||||
assertTrue(Arrays.equals(new double[] {230, 240}, buff00));
|
||||
double buff11[] = new double[] {0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new double[] {340, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntFloatArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_32F);
|
||||
float[] floatArray = { 3.0f, 1.0f, 4.0f };
|
||||
Mat m = getTestMat(5, CvType.CV_32F);
|
||||
float buff[] = new float[4];
|
||||
|
||||
int numOfBytes = src.get(0, 0, floatArray);
|
||||
assertEquals(12, numOfBytes);
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
assertEquals(16, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[] { 110, 120, 130, 140 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
float buff00[] = new float[2];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[] {230, 240}, buff00));
|
||||
float buff11[] = new float[] {0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(4, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[] {340, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntIntArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_32S);
|
||||
int[] intArray = { 3, 1, 4, 7 };
|
||||
Mat m = getTestMat(5, CvType.CV_32SC2);
|
||||
int[] buff = new int[6];
|
||||
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
int numOfBytes = src.get(0, 0, intArray);
|
||||
assertEquals(16, numOfBytes);
|
||||
assertEquals(24, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[] { 110, 111, 120, 121, 130, 131 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
int buff00[] = new int[4];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(16, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[] {230, 231, 240, 241}, buff00));
|
||||
int buff11[] = new int[]{0, 0, 0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[] {340, 341, 0, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetIntIntShortArray() {
|
||||
Mat src = new Mat(2, 2, CvType.CV_16U);
|
||||
short[] data = { 3, 1, 4, 7 };
|
||||
Mat m = getTestMat(5, CvType.CV_16SC2);
|
||||
short[] buff = new short[6];
|
||||
|
||||
// whole Mat
|
||||
int bytesNum = m.get(1, 1, buff);
|
||||
|
||||
int numOfBytes = src.get(1, 1, data);
|
||||
assertEquals(2, numOfBytes);
|
||||
assertEquals(12, bytesNum);
|
||||
assertTrue(Arrays.equals(new short[] { 110, 111, 120, 121, 130, 131 }, buff));
|
||||
|
||||
// sub-Mat
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
short buff00[] = new short[4];
|
||||
bytesNum = sm.get(0, 0, buff00);
|
||||
assertEquals(8, bytesNum);
|
||||
assertTrue(Arrays.equals(new short[] {230, 231, 240, 241}, buff00));
|
||||
short buff11[] = new short[]{0, 0, 0, 0};
|
||||
bytesNum = sm.get(1, 1, buff11);
|
||||
assertEquals(4, bytesNum);
|
||||
assertTrue(Arrays.equals(new short[] {340, 341, 0, 0}, buff11));
|
||||
}
|
||||
|
||||
public void testGetNativeObjAddr() {
|
||||
@@ -528,9 +646,33 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntByteArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3);
|
||||
byte[] bytes = new byte[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, bytes);
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
byte[] buff = new byte[] { 0, 0, 0, 0, 0, 0 };
|
||||
byte[] buff0 = new byte[] { 10, 20, 30, 40, 50, 60 };
|
||||
byte[] buff1 = new byte[] { -1, -2, -3, -4, -5, -6 };
|
||||
|
||||
int bytesNum = m.put(1, 2, buff0);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = m.get(1, 2, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff0));
|
||||
|
||||
bytesNum = sm.put(0, 0, buff1);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = sm.get(0, 0, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff1));
|
||||
bytesNum = m.get(2, 3, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff1));
|
||||
|
||||
Mat m1 = m.row(1);
|
||||
bytesNum = m1.get(0, 2, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, buff0));
|
||||
|
||||
try {
|
||||
byte[] bytes2 = new byte[] { 10, 20, 30, 40, 50 };
|
||||
@@ -542,21 +684,41 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntDoubleArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3);
|
||||
m.put(1, 1, 10, 20, 30, 40, 50, 60);
|
||||
Mat m = new Mat(5, 5, CvType.CV_8UC3, new Scalar(1, 2, 3));
|
||||
Mat sm = m.submat(2, 4, 3, 5);
|
||||
byte[] buff = new byte[] { 0, 0, 0, 0, 0, 0 };
|
||||
|
||||
int bytesNum = m.put(1, 2, 10, 20, 30, 40, 50, 60);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = m.get(1, 2, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, new byte[]{10, 20, 30, 40, 50, 60}));
|
||||
|
||||
try {
|
||||
m.put(2, 2, 11, 22, 33, 44, 55);
|
||||
fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)");
|
||||
} catch (UnsupportedOperationException e) {
|
||||
// expected
|
||||
}
|
||||
bytesNum = sm.put(0, 0, 255, 254, 253, 252, 251, 250);
|
||||
|
||||
assertEquals(6, bytesNum);
|
||||
bytesNum = sm.get(0, 0, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, new byte[]{-1, -2, -3, -4, -5, -6}));
|
||||
bytesNum = m.get(2, 3, buff);
|
||||
assertEquals(6, bytesNum);
|
||||
assertTrue(Arrays.equals(buff, new byte[]{-1, -2, -3, -4, -5, -6}));
|
||||
}
|
||||
|
||||
public void testPutIntIntFloatArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_32FC3);
|
||||
Mat m = new Mat(5, 5, CvType.CV_32FC3, new Scalar(1, 2, 3));
|
||||
float[] elements = new float[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, elements);
|
||||
|
||||
int bytesNum = m.put(4, 3, elements);
|
||||
|
||||
assertEquals(elements.length * 4, bytesNum);
|
||||
Mat m1 = m.row(4);
|
||||
float buff[] = new float[3];
|
||||
bytesNum = m1.get(0, 4, buff);
|
||||
assertEquals(buff.length * 4, bytesNum);
|
||||
assertTrue(Arrays.equals(new float[]{40, 50, 60}, buff));
|
||||
assertArrayEquals(new double[]{10, 20, 30}, m.get(4, 3), EPS);
|
||||
|
||||
try {
|
||||
float[] elements2 = new float[] { 10, 20, 30, 40, 50 };
|
||||
@@ -568,9 +730,18 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntIntArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_32SC3);
|
||||
Mat m = new Mat(5, 5, CvType.CV_32SC3, new Scalar(-1, -2, -3));
|
||||
int[] elements = new int[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, elements);
|
||||
|
||||
int bytesNum = m.put(0, 4, elements);
|
||||
|
||||
assertEquals(elements.length * 4, bytesNum);
|
||||
Mat m1 = m.col(4);
|
||||
int buff[] = new int[3];
|
||||
bytesNum = m1.get(0, 0, buff);
|
||||
assertEquals(buff.length * 4, bytesNum);
|
||||
assertTrue(Arrays.equals(new int[]{10, 20, 30}, buff));
|
||||
assertArrayEquals(new double[]{40, 50, 60}, m.get(1, 0), EPS);
|
||||
|
||||
try {
|
||||
int[] elements2 = new int[] { 10, 20, 30, 40, 50 };
|
||||
@@ -582,9 +753,17 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testPutIntIntShortArray() {
|
||||
Mat m = new Mat(5, 5, CvType.CV_16SC3);
|
||||
Mat m = new Mat(5, 5, CvType.CV_16SC3, new Scalar(-1, -2, -3));
|
||||
short[] elements = new short[] { 10, 20, 30, 40, 50, 60 };
|
||||
m.put(1, 1, elements);
|
||||
|
||||
int bytesNum = m.put(2, 3, elements);
|
||||
|
||||
assertEquals(elements.length * 2, bytesNum);
|
||||
Mat m1 = m.col(3);
|
||||
short buff[] = new short[3];
|
||||
bytesNum = m1.get(2, 0, buff);
|
||||
assertTrue(Arrays.equals(new short[]{10, 20, 30}, buff));
|
||||
assertArrayEquals(new double[]{40, 50, 60}, m.get(2, 4), EPS);
|
||||
|
||||
try {
|
||||
short[] elements2 = new short[] { 10, 20, 30, 40, 50 };
|
||||
@@ -692,6 +871,15 @@ public class MatTest extends OpenCVTestCase {
|
||||
assertMatEqual(gray127, gray0);
|
||||
}
|
||||
|
||||
public void testSetToScalarMask() {
|
||||
Mat mask = gray0.clone();
|
||||
mask.put(1, 1, 1, 2, 3);
|
||||
gray0.setTo(new Scalar(1), mask);
|
||||
assertEquals(3, Core.countNonZero(gray0));
|
||||
Core.subtract(gray0, mask, gray0);
|
||||
assertEquals(0, Core.countNonZero(gray0));
|
||||
}
|
||||
|
||||
public void testSize() {
|
||||
assertEquals(new Size(matSize, matSize), gray0.size());
|
||||
|
||||
|
@@ -86,18 +86,11 @@ public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, 0.643284f),
|
||||
new DMatch(1, 1, 0, 0.92945856f),
|
||||
new DMatch(2, 1, 0, 0.2841479f),
|
||||
new DMatch(3, 1, 0, 0.9194034f),
|
||||
new DMatch(4, 1, 0, 0.3006621f)
|
||||
*/
|
||||
new DMatch(0, 0, 0, 1.049694f),
|
||||
new DMatch(1, 0, 0, 1.083795f),
|
||||
new DMatch(2, 1, 0, 0.484352f),
|
||||
new DMatch(3, 0, 0, 1.098605f),
|
||||
new DMatch(4, 1, 0, 0.494587f)
|
||||
new DMatch(0, 0, 0, 1.049694f),
|
||||
new DMatch(1, 0, 0, 1.098605f),
|
||||
new DMatch(2, 1, 0, 0.494587f),
|
||||
new DMatch(3, 1, 0, 0.484352f),
|
||||
new DMatch(4, 0, 0, 1.083795f)
|
||||
};
|
||||
|
||||
super.setUp();
|
||||
@@ -183,6 +176,9 @@ public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
|
||||
Log.d("knnMatch", "train = " + train);
|
||||
Log.d("knnMatch", "query = " + query);
|
||||
/*
|
||||
Log.d("knnMatch", "train = " + train);
|
||||
Log.d("knnMatch", "query = " + query);
|
||||
|
||||
matcher.add(train);
|
||||
matcher.knnMatch(query, matches, k);
|
||||
*/
|
||||
@@ -190,7 +186,7 @@ public class BruteForceDescriptorMatcherTest extends OpenCVTestCase {
|
||||
for(int i = 0; i<matches.size(); i++)
|
||||
{
|
||||
MatOfDMatch vdm = matches.get(i);
|
||||
Log.d("knn", "vdm["+i+"]="+vdm.dump());
|
||||
//Log.d("knn", "vdm["+i+"]="+vdm.dump());
|
||||
assertTrue(Math.min(k, train.rows()) >= vdm.total());
|
||||
for(DMatch dm : vdm.toArray())
|
||||
{
|
||||
|
@@ -189,9 +189,11 @@ public class BruteForceHammingLUTDescriptorMatcherTest extends OpenCVTestCase {
|
||||
|
||||
matcher.match(query, train, matches);
|
||||
|
||||
/*
|
||||
OpenCVTestRunner.Log("matches found: " + matches.size());
|
||||
for (DMatch m : matches.toArray())
|
||||
OpenCVTestRunner.Log(m.toString());
|
||||
*/
|
||||
|
||||
assertArrayDMatchEquals(truth, matches.toArray(), EPS);
|
||||
}
|
||||
|
@@ -84,18 +84,11 @@ public class BruteForceL1DescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, 3.175296f),
|
||||
new DMatch(1, 1, 0, 3.5954158f),
|
||||
new DMatch(2, 1, 0, 1.2537984f),
|
||||
new DMatch(3, 1, 0, 3.5761614f),
|
||||
new DMatch(4, 1, 0, 1.3250958f)
|
||||
*/
|
||||
new DMatch(0, 1, 0, 6.920234f),
|
||||
new DMatch(1, 0, 0, 6.1294847f),
|
||||
new DMatch(2, 1, 0, 2.6545324f),
|
||||
new DMatch(3, 1, 0, 6.1675916f),
|
||||
new DMatch(4, 1, 0, 2.679859f)
|
||||
new DMatch(0, 1, 0, 6.9202342f),
|
||||
new DMatch(1, 1, 0, 6.1675916f),
|
||||
new DMatch(2, 1, 0, 2.6798589f),
|
||||
new DMatch(3, 1, 0, 2.6545324f),
|
||||
new DMatch(4, 0, 0, 6.1294847f)
|
||||
};
|
||||
super.setUp();
|
||||
}
|
||||
|
@@ -89,18 +89,11 @@ public class BruteForceSL2DescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, sqr(0.643284f)),
|
||||
new DMatch(1, 1, 0, sqr(0.92945856f)),
|
||||
new DMatch(2, 1, 0, sqr(0.2841479f)),
|
||||
new DMatch(3, 1, 0, sqr(0.9194034f)),
|
||||
new DMatch(4, 1, 0, sqr(0.3006621f))
|
||||
*/
|
||||
new DMatch(0, 0, 0, 1.1018577f),
|
||||
new DMatch(1, 0, 0, 1.1746116f),
|
||||
new DMatch(2, 1, 0, 0.23459719f),
|
||||
new DMatch(3, 0, 0, 1.2069331f),
|
||||
new DMatch(4, 1, 0, 0.2446168f)
|
||||
new DMatch(1, 0, 0, 1.2069331f),
|
||||
new DMatch(2, 1, 0, 0.2446168f),
|
||||
new DMatch(3, 1, 0, 0.2345972f),
|
||||
new DMatch(4, 0, 0, 1.1746116f)
|
||||
};
|
||||
|
||||
super.setUp();
|
||||
|
@@ -158,18 +158,11 @@ public class FlannBasedDescriptorMatcherTest extends OpenCVTestCase {
|
||||
matSize = 100;
|
||||
|
||||
truth = new DMatch[] {
|
||||
/*
|
||||
new DMatch(0, 0, 0, 0.643284f),
|
||||
new DMatch(1, 1, 0, 0.92945856f),
|
||||
new DMatch(2, 1, 0, 0.2841479f),
|
||||
new DMatch(3, 1, 0, 0.9194034f),
|
||||
new DMatch(4, 1, 0, 0.3006621f)
|
||||
*/
|
||||
new DMatch(0, 0, 0, 1.049694f),
|
||||
new DMatch(1, 0, 0, 1.083795f),
|
||||
new DMatch(2, 1, 0, 0.484352f),
|
||||
new DMatch(3, 0, 0, 1.098605f),
|
||||
new DMatch(4, 1, 0, 0.494587f)
|
||||
new DMatch(1, 0, 0, 1.098605f),
|
||||
new DMatch(2, 1, 0, 0.494587f),
|
||||
new DMatch(3, 1, 0, 0.484352f),
|
||||
new DMatch(4, 0, 0, 1.083795f)
|
||||
};
|
||||
|
||||
super.setUp();
|
||||
|
@@ -16,6 +16,11 @@ public class ORBDescriptorExtractorTest extends OpenCVTestCase {
|
||||
DescriptorExtractor extractor;
|
||||
int matSize;
|
||||
|
||||
public static void assertDescriptorsClose(Mat expected, Mat actual, int allowedDistance) {
|
||||
double distance = Core.norm(expected, actual, Core.NORM_HAMMING);
|
||||
assertTrue("expected:<" + allowedDistance + "> but was:<" + distance + ">", distance <= allowedDistance);
|
||||
}
|
||||
|
||||
private Mat getTestImg() {
|
||||
Mat cross = new Mat(matSize, matSize, CvType.CV_8U, new Scalar(255));
|
||||
Core.line(cross, new Point(20, matSize / 2), new Point(matSize - 21, matSize / 2), new Scalar(100), 2);
|
||||
@@ -50,7 +55,7 @@ public class ORBDescriptorExtractorTest extends OpenCVTestCase {
|
||||
6, 74, 6, 129, 2, 130, 56, 0, 36, 132, 66, 165, 172, 6, 3, 72, 102, 61, 163, 214, 0, 144, 65, 232, 4, 32, 138, 129, 4, 21, 37, 88);
|
||||
}
|
||||
};
|
||||
assertMatEqual(truth, descriptors);
|
||||
assertDescriptorsClose(truth, descriptors, 1);
|
||||
}
|
||||
|
||||
public void testCreate() {
|
||||
@@ -87,7 +92,7 @@ public class ORBDescriptorExtractorTest extends OpenCVTestCase {
|
||||
6, 10, 22, 5, 2, 130, 56, 0, 44, 164, 66, 165, 140, 6, 1, 72, 38, 61, 163, 210, 0, 208, 1, 104, 4, 32, 10, 131, 0, 37, 37, 67);
|
||||
}
|
||||
};
|
||||
assertMatEqual(truth, descriptors);
|
||||
assertDescriptorsClose(truth, descriptors, 1);
|
||||
}
|
||||
|
||||
public void testWrite() {
|
||||
|
@@ -9,6 +9,7 @@ import org.opencv.core.CvType;
|
||||
import org.opencv.core.Mat;
|
||||
import org.opencv.core.MatOfFloat;
|
||||
import org.opencv.core.MatOfInt;
|
||||
import org.opencv.core.MatOfInt4;
|
||||
import org.opencv.core.MatOfPoint;
|
||||
import org.opencv.core.MatOfPoint2f;
|
||||
import org.opencv.core.Point;
|
||||
@@ -242,9 +243,9 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
|
||||
public void testCalcBackProject() {
|
||||
List<Mat> images = Arrays.asList(grayChess);
|
||||
MatOfInt channels = new MatOfInt(1, new int[]{0});
|
||||
MatOfInt histSize = new MatOfInt(1, new int[]{10});
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0);
|
||||
MatOfInt histSize = new MatOfInt(10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f);
|
||||
|
||||
Mat hist = new Mat();
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
@@ -259,9 +260,9 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat() {
|
||||
List<Mat> images = Arrays.asList(gray128);
|
||||
MatOfInt channels = new MatOfInt(1, new int[]{0});
|
||||
MatOfInt histSize = new MatOfInt(1, new int[]{10});
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0);
|
||||
MatOfInt histSize = new MatOfInt(10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f);
|
||||
Mat hist = new Mat();
|
||||
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
@@ -274,11 +275,11 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
assertMatEqual(truth, hist, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2d() {
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2D() {
|
||||
List<Mat> images = Arrays.asList(gray255, gray128);
|
||||
MatOfInt channels = new MatOfInt(1, 0, 1);
|
||||
MatOfInt histSize = new MatOfInt(1, 10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0, 1);
|
||||
MatOfInt histSize = new MatOfInt(10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
|
||||
Mat hist = new Mat();
|
||||
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
@@ -291,11 +292,49 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
assertMatEqual(truth, hist, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat3D() {
|
||||
List<Mat> images = Arrays.asList(rgbLena);
|
||||
|
||||
Mat hist3D = new Mat();
|
||||
List<Mat> histList = Arrays.asList( new Mat[] {new Mat(), new Mat(), new Mat()} );
|
||||
|
||||
MatOfInt histSize = new MatOfInt(10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f);
|
||||
|
||||
for(int i=0; i<rgbLena.channels(); i++)
|
||||
{
|
||||
Imgproc.calcHist(images, new MatOfInt(i), new Mat(), histList.get(i), histSize, ranges);
|
||||
|
||||
assertEquals(10, histList.get(i).checkVector(1));
|
||||
}
|
||||
|
||||
Core.merge(histList, hist3D);
|
||||
|
||||
assertEquals(CvType.CV_32FC3, hist3D.type());
|
||||
assertEquals(10, hist3D.checkVector(3));
|
||||
|
||||
Mat truth = new Mat(10, 1, CvType.CV_32FC3);
|
||||
truth.put(0, 0,
|
||||
0, 24870, 0,
|
||||
1863, 31926, 1,
|
||||
56682, 37677, 2260,
|
||||
77278, 44751, 32436,
|
||||
69397, 41343, 18526,
|
||||
27180, 40407, 18658,
|
||||
21101, 15993, 32042,
|
||||
8343, 18585, 47786,
|
||||
300, 6567, 80988,
|
||||
0, 25, 29447
|
||||
);
|
||||
|
||||
assertMatEqual(truth, hist3D, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloatBoolean() {
|
||||
List<Mat> images = Arrays.asList(gray255, gray128);
|
||||
MatOfInt channels = new MatOfInt(1, 0, 1);
|
||||
MatOfInt histSize = new MatOfInt(1, 10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(1, 0f, 256f, 0f, 256f);
|
||||
MatOfInt channels = new MatOfInt(0, 1);
|
||||
MatOfInt histSize = new MatOfInt(10, 10);
|
||||
MatOfFloat ranges = new MatOfFloat(0f, 256f, 0f, 256f);
|
||||
Mat hist = new Mat();
|
||||
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges, true);
|
||||
@@ -382,26 +421,62 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testConvexHullMatMat() {
|
||||
Mat points = new Mat(1, 6, CvType.CV_32FC2);
|
||||
points.put(0, 0, 2, 0, 4, 0, 3, 2, 0, 2, 2, 1, 3, 1);
|
||||
MatOfPoint points = new MatOfPoint(
|
||||
new Point(20, 0),
|
||||
new Point(40, 0),
|
||||
new Point(30, 20),
|
||||
new Point(0, 20),
|
||||
new Point(20, 10),
|
||||
new Point(30, 10)
|
||||
);
|
||||
|
||||
MatOfInt hull = new MatOfInt();
|
||||
|
||||
Imgproc.convexHull(points, dst);
|
||||
Imgproc.convexHull(points, hull);
|
||||
|
||||
Mat expHull = new Mat(4, 1, CvType.CV_32FC2);
|
||||
expHull.put(0, 0, 4, 0, 3, 2, 0, 2, 2, 0);
|
||||
assertMatEqual(expHull, dst, EPS);
|
||||
MatOfInt expHull = new MatOfInt(
|
||||
1, 2, 3, 0
|
||||
);
|
||||
assertMatEqual(expHull, hull, EPS);
|
||||
}
|
||||
|
||||
public void testConvexHullMatMatBooleanBoolean() {
|
||||
Mat points = new Mat(1, 6, CvType.CV_32FC2);
|
||||
points.put(0, 0, 2, 0, 4, 0, 3, 2, 0, 2, 2, 1, 3, 1);
|
||||
MatOfPoint points = new MatOfPoint(
|
||||
new Point(2, 0),
|
||||
new Point(4, 0),
|
||||
new Point(3, 2),
|
||||
new Point(0, 2),
|
||||
new Point(2, 1),
|
||||
new Point(3, 1)
|
||||
);
|
||||
|
||||
MatOfInt hull = new MatOfInt();
|
||||
|
||||
Imgproc.convexHull(points, dst, true, true);
|
||||
// TODO_: write better test (last param == false)
|
||||
Imgproc.convexHull(points, hull, true);
|
||||
|
||||
Mat expHull = new Mat(4, 1, CvType.CV_32FC2);
|
||||
expHull.put(0, 0, 0, 2, 3, 2, 4, 0, 2, 0);
|
||||
assertMatEqual(expHull, dst, EPS);
|
||||
MatOfInt expHull = new MatOfInt(
|
||||
3, 2, 1, 0
|
||||
);
|
||||
assertMatEqual(expHull, hull, EPS);
|
||||
}
|
||||
|
||||
public void testConvexityDefects() {
|
||||
MatOfPoint points = new MatOfPoint(
|
||||
new Point(20, 0),
|
||||
new Point(40, 0),
|
||||
new Point(30, 20),
|
||||
new Point(0, 20),
|
||||
new Point(20, 10),
|
||||
new Point(30, 10)
|
||||
);
|
||||
|
||||
MatOfInt hull = new MatOfInt();
|
||||
Imgproc.convexHull(points, hull);
|
||||
|
||||
MatOfInt4 convexityDefects = new MatOfInt4();
|
||||
Imgproc.convexityDefects(points, hull, convexityDefects);
|
||||
|
||||
assertMatEqual(new MatOfInt4(3, 0, 5, 3620), convexityDefects);
|
||||
}
|
||||
|
||||
public void testCopyMakeBorderMatMatIntIntIntIntInt() {
|
||||
@@ -1277,11 +1352,11 @@ public class ImgprocTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testIsContourConvex() {
|
||||
MatOfPoint2f contour1 = new MatOfPoint2f(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
|
||||
MatOfPoint contour1 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 4));
|
||||
|
||||
assertFalse(Imgproc.isContourConvex(contour1));
|
||||
|
||||
MatOfPoint2f contour2 = new MatOfPoint2f(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
|
||||
MatOfPoint contour2 = new MatOfPoint(new Point(0, 0), new Point(10, 0), new Point(10, 10), new Point(5, 6));
|
||||
|
||||
assertTrue(Imgproc.isContourConvex(contour2));
|
||||
}
|
||||
|
@@ -1,6 +1,6 @@
|
||||
package org.opencv.test.imgproc;
|
||||
|
||||
import org.opencv.core.MatOfFloat;
|
||||
import org.opencv.core.MatOfFloat6;
|
||||
import org.opencv.core.Point;
|
||||
import org.opencv.core.Rect;
|
||||
import org.opencv.imgproc.Subdiv2D;
|
||||
@@ -50,7 +50,7 @@ public class Subdiv2DTest extends OpenCVTestCase {
|
||||
s2d.insert( new Point(20, 10) );
|
||||
s2d.insert( new Point(20, 20) );
|
||||
s2d.insert( new Point(10, 20) );
|
||||
MatOfFloat triangles = new MatOfFloat();
|
||||
MatOfFloat6 triangles = new MatOfFloat6();
|
||||
s2d.getTriangleList(triangles);
|
||||
assertEquals(10, triangles.rows());
|
||||
/*
|
||||
|
Reference in New Issue
Block a user