Java: fixed Mats comparison; added resahpe mathod to core.Mat; fixed test resources extraction.
This commit is contained in:
Andrey Kamaev
parent
3f5089411a
commit
954f3c1eb9
@ -915,7 +915,7 @@ Reprojects a disparity image to 3D space.
|
||||
.. ocv:cfunction:: void cvReprojectImageTo3D( const CvArr* disparity, CvArr* _3dImage, const CvMat* Q, int handleMissingValues=0)
|
||||
.. ocv:pyoldfunction:: cv.ReprojectImageTo3D(disparity, _3dImage, Q, handleMissingValues=0) -> None
|
||||
|
||||
:param disparity: Input single-channel 16-bit signed or 32-bit floating-point disparity image.
|
||||
:param disparity: Input single-channel 8-bit unsigned, 16-bit signed, 32-bit signed or 32-bit floating-point disparity image.
|
||||
|
||||
:param _3dImage: Output 3-channel floating-point image of the same size as ``disparity`` . Each element of ``_3dImage(x,y)`` contains 3D coordinates of the point ``(x,y)`` computed from the disparity map.
|
||||
|
||||
|
||||
@ -115,6 +115,44 @@ public class OpenCVTestCase extends TestCase {
|
||||
v1.put(0, 0, 1.0, 3.0, 2.0);
|
||||
v2 = new Mat(1, 3, CvType.CV_32F);
|
||||
v2.put(0, 0, 2.0, 1.0, 3.0);
|
||||
|
||||
low.release();
|
||||
high.release();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void tearDown() throws Exception {
|
||||
|
||||
gray0.release();
|
||||
gray1.release();
|
||||
gray2.release();
|
||||
gray3.release();
|
||||
gray9.release();
|
||||
gray127.release();
|
||||
gray128.release();
|
||||
gray255.release();
|
||||
gray_16u_256.release();
|
||||
gray_16s_1024.release();
|
||||
grayRnd.release();
|
||||
gray0_32f.release();
|
||||
gray1_32f.release();
|
||||
gray3_32f.release();
|
||||
gray9_32f.release();
|
||||
gray255_32f.release();
|
||||
grayE_32f.release();
|
||||
grayE_32f.release();
|
||||
grayRnd_32f.release();
|
||||
gray0_32f_1d.release();
|
||||
gray0_64f.release();
|
||||
gray0_64f_1d.release();
|
||||
rgba0.release();
|
||||
rgba128.release();
|
||||
rgbLena.release();
|
||||
grayChess.release();
|
||||
v1.release();
|
||||
v2.release();
|
||||
|
||||
super.tearDown();
|
||||
}
|
||||
|
||||
public static void assertMatEqual(Mat m1, Mat m2) {
|
||||
@ -133,30 +171,31 @@ public class OpenCVTestCase extends TestCase {
|
||||
compareMats(expected, actual, eps, false);
|
||||
}
|
||||
|
||||
static private void compareMats(Mat m1, Mat m2, boolean isEqualityMeasured) {
|
||||
// OpenCVTestRunner.Log(m1.toString());
|
||||
// OpenCVTestRunner.Log(m2.toString());
|
||||
|
||||
if (m1.type() != m2.type() || m1.cols() != m2.cols()
|
||||
|| m1.rows() != m2.rows()) {
|
||||
static private void compareMats(Mat expected, Mat actual, boolean isEqualityMeasured) {
|
||||
if (expected.type() != actual.type() || expected.cols() != actual.cols()
|
||||
|| expected.rows() != actual.rows()) {
|
||||
throw new UnsupportedOperationException();
|
||||
} else if (m1.channels() == 1) {
|
||||
if (isEqualityMeasured) {
|
||||
assertTrue(CalcPercentageOfDifference(m1, m2) == 0.0);
|
||||
} else {
|
||||
assertTrue(CalcPercentageOfDifference(m1, m2) != 0.0);
|
||||
}
|
||||
} else {
|
||||
for (int coi = 0; coi < m1.channels(); coi++) {
|
||||
Mat m1c = getCOI(m1, coi);
|
||||
Mat m2c = getCOI(m2, coi);
|
||||
if (isEqualityMeasured) {
|
||||
assertTrue(CalcPercentageOfDifference(m1c, m2c) == 0.0);
|
||||
} else {
|
||||
assertTrue(CalcPercentageOfDifference(m1c, m2c) != 0.0);
|
||||
}
|
||||
}
|
||||
|
||||
if (expected.depth() == CvType.CV_32F || expected.depth() == CvType.CV_64F){
|
||||
if (isEqualityMeasured)
|
||||
throw new UnsupportedOperationException("Floating-point Mats must not be checked for exact match. Use assertMatEqual(Mat expected, Mat actual, double eps) instead.");
|
||||
else
|
||||
throw new UnsupportedOperationException("Floating-point Mats must not be checked for exact match. Use assertMatNotEqual(Mat expected, Mat actual, double eps) instead.");
|
||||
}
|
||||
|
||||
Mat diff = new Mat();
|
||||
Core.absdiff(expected, actual, diff);
|
||||
Mat reshaped = diff.reshape(1);
|
||||
int mistakes = Core.countNonZero(reshaped);
|
||||
|
||||
reshaped.release();
|
||||
diff.release();
|
||||
|
||||
if(isEqualityMeasured)
|
||||
assertTrue("Mats are different in " + mistakes + " points", 0 == mistakes);
|
||||
else
|
||||
assertFalse("Mats are equal", 0 == mistakes);
|
||||
}
|
||||
|
||||
static private void compareMats(Mat expected, Mat actual, double eps, boolean isEqualityMeasured) {
|
||||
@ -167,34 +206,13 @@ public class OpenCVTestCase extends TestCase {
|
||||
Mat diff = new Mat();
|
||||
Core.absdiff(expected, actual, diff);
|
||||
if(isEqualityMeasured)
|
||||
assertTrue("Max difference between expected and actiual values is bigger than " + eps,
|
||||
assertTrue("Max difference between expected and actiual Mats is bigger than " + eps,
|
||||
Core.checkRange(diff, true, new Point(), 0.0, eps));
|
||||
else
|
||||
assertFalse("Max difference between expected and actiual values is less than " + eps,
|
||||
assertFalse("Max difference between expected and actiual Mats is less than " + eps,
|
||||
Core.checkRange(diff, true, new Point(), 0.0, eps));
|
||||
}
|
||||
|
||||
static private Mat getCOI(Mat m, int coi) {
|
||||
Mat ch = new Mat(m.rows(), m.cols(), m.depth());
|
||||
|
||||
for (int i = 0; i < m.rows(); i++)
|
||||
for (int j = 0; j < m.cols(); j++) {
|
||||
double pixel[] = m.get(i, j);
|
||||
ch.put(i, j, pixel[coi]);
|
||||
}
|
||||
|
||||
return ch;
|
||||
}
|
||||
|
||||
static private double CalcPercentageOfDifference(Mat m1, Mat m2) {
|
||||
Mat cmp = new Mat(0, 0, CvType.CV_8U);
|
||||
Core.compare(m1, m2, cmp, Core.CMP_EQ);
|
||||
double difference = 100.0 * (1.0 - Double.valueOf(Core
|
||||
.countNonZero(cmp)) / Double.valueOf(cmp.rows() * cmp.cols()));
|
||||
|
||||
return difference;
|
||||
}
|
||||
|
||||
public void test_1(String label) {
|
||||
OpenCVTestRunner
|
||||
.Log("================================================");
|
||||
|
||||
@ -1,27 +1,27 @@
|
||||
package org.opencv.test;
|
||||
|
||||
import java.io.FileOutputStream;
|
||||
|
||||
import android.content.Context;
|
||||
import android.graphics.Bitmap;
|
||||
import android.graphics.Bitmap.CompressFormat;
|
||||
import android.graphics.BitmapFactory;
|
||||
import android.test.AndroidTestRunner;
|
||||
import android.test.InstrumentationTestRunner;
|
||||
import android.util.Log;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
/**
|
||||
* This only class is Android specific.
|
||||
* The original idea about test order randomization is from marek.defecinski blog.
|
||||
* This only class is Android specific. The original idea about test order
|
||||
* randomization is from marek.defecinski blog.
|
||||
*
|
||||
* @see <a href="http://opencv.itseez.com">OpenCV</a>
|
||||
*/
|
||||
|
||||
public class OpenCVTestRunner extends InstrumentationTestRunner {
|
||||
|
||||
public static String LENA_PATH = "/data/data/org.opencv.test/files/lena.jpg";
|
||||
public static String CHESS_PATH = "/data/data/org.opencv.test/files/chessboard.jpg";
|
||||
public static String LBPCASCADE_FRONTALFACE_PATH = "/mnt/sdcard/lbpcascade_frontalface.xml";
|
||||
public static String LENA_PATH;
|
||||
public static String CHESS_PATH;
|
||||
public static String LBPCASCADE_FRONTALFACE_PATH;
|
||||
|
||||
private AndroidTestRunner androidTestRunner;
|
||||
private static String TAG = "opencv_test_java";
|
||||
@ -32,13 +32,12 @@ public class OpenCVTestRunner extends InstrumentationTestRunner {
|
||||
|
||||
@Override
|
||||
public void onStart() {
|
||||
ExportResourceImage("lena.jpg", R.drawable.lena);
|
||||
ExportResourceImage("chessboard.jpg", R.drawable.chessboard);
|
||||
LENA_PATH = ExportResource(R.drawable.lena);
|
||||
CHESS_PATH = ExportResource(R.drawable.chessboard);
|
||||
LBPCASCADE_FRONTALFACE_PATH = ExportResource(R.raw.lbpcascade_frontalface);
|
||||
|
||||
//FIXME: implement export of the cascade
|
||||
|
||||
//List<TestCase> testCases = androidTestRunner.getTestCases();
|
||||
//Collections.shuffle(testCases); //shuffle the tests order
|
||||
// List<TestCase> testCases = androidTestRunner.getTestCases();
|
||||
// Collections.shuffle(testCases); //shuffle the tests order
|
||||
|
||||
super.onStart();
|
||||
}
|
||||
@ -49,16 +48,31 @@ public class OpenCVTestRunner extends InstrumentationTestRunner {
|
||||
return androidTestRunner;
|
||||
}
|
||||
|
||||
private void ExportResourceImage(String image, int rId) {
|
||||
private String ExportResource(int resourceId) {
|
||||
String fullname = getContext().getResources().getString(resourceId);
|
||||
String resName = fullname.substring(fullname.lastIndexOf("/") + 1);
|
||||
try {
|
||||
Bitmap mBitmap = BitmapFactory.decodeResource(this.getContext().getResources(), rId);
|
||||
FileOutputStream fos = this.getContext().openFileOutput(image, Context.MODE_WORLD_READABLE);
|
||||
mBitmap.compress(CompressFormat.JPEG, 100, fos);
|
||||
fos.flush();
|
||||
fos.close();
|
||||
InputStream is = getContext().getResources().openRawResource(
|
||||
resourceId);
|
||||
File resDir = getContext().getDir("testdata", Context.MODE_PRIVATE);
|
||||
File resFile = new File(resDir, resName);
|
||||
|
||||
FileOutputStream os = new FileOutputStream(resFile);
|
||||
|
||||
byte[] buffer = new byte[4096];
|
||||
int bytesRead;
|
||||
while ((bytesRead = is.read(buffer)) != -1) {
|
||||
os.write(buffer, 0, bytesRead);
|
||||
}
|
||||
catch (Exception e) {
|
||||
Log("Tried to write " + image + ", but: " + e.toString());
|
||||
is.close();
|
||||
os.close();
|
||||
|
||||
return resFile.getAbsolutePath();
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
Log("Failed to export resource " + resName + ". Exception thrown: "
|
||||
+ e);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
@ -52,8 +52,8 @@ public class calib3dTest extends OpenCVTestCase {
|
||||
|
||||
Calib3d.composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3);
|
||||
|
||||
assertMatEqual(outRvec, rvec3);
|
||||
assertMatEqual(outTvec, tvec3);
|
||||
assertMatEqual(outRvec, rvec3, EPS);
|
||||
assertMatEqual(outTvec, tvec3, EPS);
|
||||
}
|
||||
|
||||
public void testComposeRTMatMatMatMatMatMatMat() {
|
||||
@ -367,15 +367,122 @@ public class calib3dTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testReprojectImageTo3DMatMatMat() {
|
||||
fail("Not yet implemented");
|
||||
Mat transformMatrix = new Mat(4,4,CvType.CV_64F);
|
||||
transformMatrix.put(0, 0,
|
||||
0, 1, 0, 0,
|
||||
1, 0, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1);
|
||||
|
||||
Mat disparity = new Mat(matSize,matSize,CvType.CV_32F);
|
||||
|
||||
float[] disp = new float[matSize * matSize];
|
||||
for (int i = 0; i < matSize; i++)
|
||||
for(int j = 0; j < matSize; j++)
|
||||
disp[i * matSize + j] = i - j;
|
||||
disparity.put(0, 0, disp);
|
||||
|
||||
Mat _3dPoints = new Mat();
|
||||
|
||||
Calib3d.reprojectImageTo3D(disparity, _3dPoints, transformMatrix);
|
||||
|
||||
assertEquals(CvType.CV_32FC3, _3dPoints.type());
|
||||
assertEquals(matSize, _3dPoints.rows());
|
||||
assertEquals(matSize, _3dPoints.cols());
|
||||
|
||||
truth = new Mat(matSize,matSize,CvType.CV_32FC3);
|
||||
|
||||
float[] _truth = new float[matSize * matSize * 3];
|
||||
for (int i = 0; i < matSize; i++)
|
||||
for(int j = 0; j < matSize; j++)
|
||||
{
|
||||
_truth[(i * matSize + j) * 3 + 0] = i;
|
||||
_truth[(i * matSize + j) * 3 + 1] = j;
|
||||
_truth[(i * matSize + j) * 3 + 2] = i-j;
|
||||
}
|
||||
truth.put(0, 0, _truth);
|
||||
|
||||
assertMatEqual(truth, _3dPoints, EPS);
|
||||
}
|
||||
|
||||
public void testReprojectImageTo3DMatMatMatBoolean() {
|
||||
fail("Not yet implemented");
|
||||
Mat transformMatrix = new Mat(4,4,CvType.CV_64F);
|
||||
transformMatrix.put(0, 0,
|
||||
0, 1, 0, 0,
|
||||
1, 0, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1);
|
||||
|
||||
Mat disparity = new Mat(matSize,matSize,CvType.CV_32F);
|
||||
|
||||
float[] disp = new float[matSize * matSize];
|
||||
for (int i = 0; i < matSize; i++)
|
||||
for(int j = 0; j < matSize; j++)
|
||||
disp[i * matSize + j] = i - j;
|
||||
disp[0] = -Float.MAX_VALUE;
|
||||
disparity.put(0, 0, disp);
|
||||
|
||||
Mat _3dPoints = new Mat();
|
||||
|
||||
Calib3d.reprojectImageTo3D(disparity, _3dPoints, transformMatrix, true);
|
||||
|
||||
assertEquals(CvType.CV_32FC3, _3dPoints.type());
|
||||
assertEquals(matSize, _3dPoints.rows());
|
||||
assertEquals(matSize, _3dPoints.cols());
|
||||
|
||||
truth = new Mat(matSize,matSize,CvType.CV_32FC3);
|
||||
|
||||
float[] _truth = new float[matSize * matSize * 3];
|
||||
for (int i = 0; i < matSize; i++)
|
||||
for(int j = 0; j < matSize; j++)
|
||||
{
|
||||
_truth[(i * matSize + j) * 3 + 0] = i;
|
||||
_truth[(i * matSize + j) * 3 + 1] = j;
|
||||
_truth[(i * matSize + j) * 3 + 2] = i-j;
|
||||
}
|
||||
_truth[2] = 10000;
|
||||
truth.put(0, 0, _truth);
|
||||
|
||||
assertMatEqual(truth, _3dPoints, EPS);
|
||||
}
|
||||
|
||||
public void testReprojectImageTo3DMatMatMatBooleanInt() {
|
||||
fail("Not yet implemented");
|
||||
Mat transformMatrix = new Mat(4,4,CvType.CV_64F);
|
||||
transformMatrix.put(0, 0,
|
||||
0, 1, 0, 0,
|
||||
1, 0, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1);
|
||||
|
||||
Mat disparity = new Mat(matSize,matSize,CvType.CV_32F);
|
||||
|
||||
float[] disp = new float[matSize * matSize];
|
||||
for (int i = 0; i < matSize; i++)
|
||||
for(int j = 0; j < matSize; j++)
|
||||
disp[i * matSize + j] = i - j;
|
||||
disparity.put(0, 0, disp);
|
||||
|
||||
Mat _3dPoints = new Mat();
|
||||
|
||||
Calib3d.reprojectImageTo3D(disparity, _3dPoints, transformMatrix, false, CvType.CV_16S);
|
||||
|
||||
assertEquals(CvType.CV_16SC3, _3dPoints.type());
|
||||
assertEquals(matSize, _3dPoints.rows());
|
||||
assertEquals(matSize, _3dPoints.cols());
|
||||
|
||||
truth = new Mat(matSize,matSize,CvType.CV_16SC3);
|
||||
|
||||
short[] _truth = new short[matSize * matSize * 3];
|
||||
for (short i = 0; i < matSize; i++)
|
||||
for(short j = 0; j < matSize; j++)
|
||||
{
|
||||
_truth[(i * matSize + j) * 3 + 0] = i;
|
||||
_truth[(i * matSize + j) * 3 + 1] = j;
|
||||
_truth[(i * matSize + j) * 3 + 2] = (short) (i-j);
|
||||
}
|
||||
truth.put(0, 0, _truth);
|
||||
|
||||
assertMatEqual(truth, _3dPoints, EPS);
|
||||
}
|
||||
|
||||
public void testRodriguesMatMat() {
|
||||
|
||||
@ -29,8 +29,8 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testColRange() {
|
||||
Mat cols = gray0.colRange(0, gray0.cols()/2);
|
||||
assertEquals(gray0.cols()/2, cols.cols());
|
||||
Mat cols = gray0.colRange(0, gray0.cols() / 2);
|
||||
assertEquals(gray0.cols() / 2, cols.cols());
|
||||
assertEquals(gray0.rows(), cols.rows());
|
||||
}
|
||||
|
||||
@ -48,7 +48,7 @@ public class MatTest extends OpenCVTestCase {
|
||||
answer.put(0, 0, 7.0, 1.0, -5.0);
|
||||
|
||||
Mat cross = v1.cross(v2);
|
||||
assertMatEqual(answer, cross);
|
||||
assertMatEqual(answer, cross, EPS);
|
||||
}
|
||||
|
||||
public void testDataAddr() {
|
||||
@ -61,11 +61,11 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testRelease() {
|
||||
assertTrue( gray0.empty() == false );
|
||||
assertTrue( gray0.rows() > 0 );
|
||||
assertTrue(gray0.empty() == false);
|
||||
assertTrue(gray0.rows() > 0);
|
||||
gray0.release();
|
||||
assertTrue( gray0.empty() == true );
|
||||
assertTrue( gray0.rows() == 0 );
|
||||
assertTrue(gray0.empty() == true);
|
||||
assertTrue(gray0.rows() == 0);
|
||||
}
|
||||
|
||||
public void testDot() {
|
||||
@ -90,7 +90,7 @@ public class MatTest extends OpenCVTestCase {
|
||||
|
||||
public void testEye() {
|
||||
Mat eye = Mat.eye(3, 3, CvType.CV_32FC1);
|
||||
assertMatEqual(eye, eye.inv());
|
||||
assertMatEqual(eye, eye.inv(), EPS);
|
||||
}
|
||||
|
||||
public void testGetIntInt() {
|
||||
@ -129,19 +129,19 @@ public class MatTest extends OpenCVTestCase {
|
||||
|
||||
public void testInv() {
|
||||
dst = grayE_32f.inv();
|
||||
assertMatEqual(grayE_32f, dst);
|
||||
assertMatEqual(grayE_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testIsContinuous() {
|
||||
assertTrue(gray0.isContinuous());
|
||||
|
||||
Mat subMat = gray0.submat(0, 0, gray0.rows()/2, gray0.cols()/2);
|
||||
Mat subMat = gray0.submat(0, 0, gray0.rows() / 2, gray0.cols() / 2);
|
||||
assertFalse(subMat.isContinuous());
|
||||
}
|
||||
|
||||
public void testIsSubmatrix() {
|
||||
assertFalse(gray0.isSubmatrix());
|
||||
Mat subMat = gray0.submat(0, 0, gray0.rows()/2, gray0.cols()/2);
|
||||
Mat subMat = gray0.submat(0, 0, gray0.rows() / 2, gray0.cols() / 2);
|
||||
assertTrue(subMat.isSubmatrix());
|
||||
}
|
||||
|
||||
@ -160,11 +160,13 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testMatIntIntCvTypeScalar() {
|
||||
dst = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U, new Scalar(127));
|
||||
dst = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U, new Scalar(
|
||||
127));
|
||||
assertFalse(dst.empty());
|
||||
assertMatEqual(dst, gray127);
|
||||
|
||||
dst = new Mat(rgba128.rows(), rgba128.cols(), CvType.CV_8UC4, Scalar.all(128));
|
||||
dst = new Mat(rgba128.rows(), rgba128.cols(), CvType.CV_8UC4,
|
||||
Scalar.all(128));
|
||||
assertFalse(dst.empty());
|
||||
assertMatEqual(dst, rgba128);
|
||||
}
|
||||
@ -178,13 +180,15 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testMatIntIntIntScalar() {
|
||||
Mat m1 = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U, new Scalar(127));
|
||||
Mat m1 = new Mat(gray127.rows(), gray127.cols(), CvType.CV_8U,
|
||||
new Scalar(127));
|
||||
assertFalse(m1.empty());
|
||||
assertMatEqual(m1, gray127);
|
||||
|
||||
Mat m2 = new Mat(gray0_32f.rows(), gray0_32f.cols(), CvType.CV_32F, new Scalar(0));
|
||||
Mat m2 = new Mat(gray0_32f.rows(), gray0_32f.cols(), CvType.CV_32F,
|
||||
new Scalar(0));
|
||||
assertFalse(m2.empty());
|
||||
assertMatEqual(m2, gray0_32f);
|
||||
assertMatEqual(m2, gray0_32f, EPS);
|
||||
}
|
||||
|
||||
public void testPutIntIntByteArray() {
|
||||
@ -214,8 +218,8 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testRowRange() {
|
||||
Mat rows = gray0.rowRange(0, gray0.rows()/2);
|
||||
assertEquals(gray0.rows()/2, rows.rows());
|
||||
Mat rows = gray0.rowRange(0, gray0.rows() / 2);
|
||||
assertEquals(gray0.rows() / 2, rows.rows());
|
||||
assertEquals(gray0.cols(), rows.cols());
|
||||
}
|
||||
|
||||
@ -229,9 +233,9 @@ public class MatTest extends OpenCVTestCase {
|
||||
}
|
||||
|
||||
public void testSubmat() {
|
||||
Mat submat = gray0.submat(0, gray0.rows()/2, 0, gray0.cols()/2);
|
||||
assertEquals(gray0.rows()/2, submat.rows());
|
||||
assertEquals(gray0.cols()/2, submat.cols());
|
||||
Mat submat = gray0.submat(0, gray0.rows() / 2, 0, gray0.cols() / 2);
|
||||
assertEquals(gray0.rows() / 2, submat.rows());
|
||||
assertEquals(gray0.cols() / 2, submat.cols());
|
||||
}
|
||||
|
||||
public void testToString() {
|
||||
|
||||
@ -39,7 +39,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
public void testAddMatMatMatMatInt() {
|
||||
Core.add(gray0, gray1, dst, gray1, CvType.CV_32F);
|
||||
assertTrue(CvType.CV_32F == dst.depth());
|
||||
assertMatEqual(gray1_32f, dst);
|
||||
assertMatEqual(gray1_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testAddWeightedMatDoubleMatDoubleDoubleMat() {
|
||||
@ -50,7 +50,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
public void testAddWeightedMatDoubleMatDoubleDoubleMatInt() {
|
||||
Core.addWeighted(gray1, 126.0, gray127, 1.0, 2.0, dst, CvType.CV_32F);
|
||||
assertTrue(CvType.CV_32F == dst.depth());
|
||||
assertMatEqual(gray255_32f, dst);
|
||||
assertMatEqual(gray255_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testBitwise_andMatMatMat() {
|
||||
@ -101,8 +101,8 @@ public class coreTest extends OpenCVTestCase {
|
||||
* TODO:
|
||||
* CV_COVAR_NORMAL
|
||||
*/);
|
||||
assertMatEqual(gray0_64f, covar);
|
||||
assertMatEqual(gray0_64f_1d, mean);
|
||||
assertMatEqual(gray0_64f, covar, EPS);
|
||||
assertMatEqual(gray0_64f_1d, mean, EPS);
|
||||
}
|
||||
|
||||
public void testCalcCovarMatrixMatMatMatIntInt() {
|
||||
@ -113,8 +113,8 @@ public class coreTest extends OpenCVTestCase {
|
||||
* TODO:
|
||||
* CV_COVAR_NORMAL
|
||||
*/, CvType.CV_32F);
|
||||
assertMatEqual(gray0_32f, covar);
|
||||
assertMatEqual(gray0_32f_1d, mean);
|
||||
assertMatEqual(gray0_32f, covar, EPS);
|
||||
assertMatEqual(gray0_32f_1d, mean, EPS);
|
||||
}
|
||||
|
||||
public void testCartToPolarMatMatMatMat() {
|
||||
@ -130,8 +130,8 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
Mat dst_angle = new Mat();
|
||||
Core.cartToPolar(x, y, dst, dst_angle);
|
||||
assertMatEqual(magnitude, dst);
|
||||
assertMatEqual(angle, dst_angle);
|
||||
assertMatEqual(magnitude, dst, EPS);
|
||||
assertMatEqual(angle, dst_angle, EPS);
|
||||
}
|
||||
|
||||
public void testCartToPolarMatMatMatMatBoolean() {
|
||||
@ -148,8 +148,8 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
Mat dst_angle = new Mat();
|
||||
Core.cartToPolar(x, y, dst, dst_angle, false);
|
||||
assertMatEqual(magnitude, dst);
|
||||
assertMatEqual(angle, dst_angle);
|
||||
assertMatEqual(magnitude, dst, EPS);
|
||||
assertMatEqual(angle, dst_angle, EPS);
|
||||
}
|
||||
|
||||
public void testCheckRangeMat() {
|
||||
@ -278,21 +278,21 @@ public class coreTest extends OpenCVTestCase {
|
||||
public void testCompleteSymmMat() {
|
||||
Core.completeSymm(grayRnd_32f);
|
||||
Core.transpose(grayRnd_32f, dst);
|
||||
assertMatEqual(grayRnd_32f, dst);
|
||||
assertMatEqual(grayRnd_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCompleteSymmMatBoolean() {
|
||||
Core.completeSymm(grayRnd_32f, true);
|
||||
Core.transpose(grayRnd_32f, dst);
|
||||
assertMatEqual(grayRnd_32f, dst);
|
||||
assertMatEqual(grayRnd_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testConvertScaleAbsMatMat() {
|
||||
Core.convertScaleAbs(gray0, dst);
|
||||
assertMatEqual(gray0, dst);
|
||||
assertMatEqual(gray0, dst, EPS);
|
||||
|
||||
Core.convertScaleAbs(gray_16u_256, dst);
|
||||
assertMatEqual(gray255, dst);
|
||||
assertMatEqual(gray255, dst, EPS);
|
||||
}
|
||||
|
||||
public void testConvertScaleAbsMatMatDouble() {
|
||||
@ -322,7 +322,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
public void testDctMatMat() {
|
||||
Core.dct(gray0_32f_1d, dst);
|
||||
assertMatEqual(gray0_32f_1d, dst);
|
||||
assertMatEqual(gray0_32f_1d, dst, EPS);
|
||||
|
||||
Mat in = new Mat(1, 4, CvType.CV_32F);
|
||||
in.put(0, 0, 135.22211, 50.811096, 102.27016, 207.6682);
|
||||
@ -331,12 +331,12 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth.put(0, 0, 247.98576, -61.252407, 94.904533, 14.013477);
|
||||
|
||||
Core.dct(in, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testDctMatMatInt() {
|
||||
Core.dct(gray0_32f_1d, dst);
|
||||
assertMatEqual(gray0_32f_1d, dst);
|
||||
assertMatEqual(gray0_32f_1d, dst, EPS);
|
||||
|
||||
Mat in = new Mat(1, 8, CvType.CV_32F);
|
||||
in.put(0, 0, 0.203056, 0.980407, 0.35312, -0.106651, 0.0399382,
|
||||
@ -347,7 +347,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
-0.32499927, -0.99302113, 0.55979407, -0.6251272);
|
||||
|
||||
Core.dct(in, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testDeterminant() {
|
||||
@ -368,7 +368,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth = new Mat(1, 4, CvType.CV_32F);
|
||||
truth.put(0, 0, 0, 0, 0, 0);
|
||||
Core.dft(src, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testDftMatMatInt() {
|
||||
@ -378,11 +378,11 @@ public class coreTest extends OpenCVTestCase {
|
||||
src.put(0, 0, 1, 2, 3, 4);
|
||||
truth.put(0, 0, 10, -2, 2, -2);
|
||||
Core.dft(src, dst, Core.DFT_REAL_OUTPUT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
|
||||
Core.dft(src, dst, Core.DFT_INVERSE);
|
||||
truth.put(0, 0, 9, -9, 1, 3);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testDftMatMatIntInt() {
|
||||
@ -392,7 +392,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth = new Mat(1, 4, CvType.CV_32F);
|
||||
truth.put(0, 0, 10, -2, 2, -2);
|
||||
Core.dft(src, dst, Core.DFT_REAL_OUTPUT, 1);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testDivideDoubleMatMat() {
|
||||
@ -460,7 +460,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
Mat destination = new Mat(matSize, matSize, CvType.CV_32F);
|
||||
destination.setTo(new Scalar(0.0));
|
||||
Core.exp(gray0_32f, destination);
|
||||
assertMatEqual(gray1_32f, destination);
|
||||
assertMatEqual(gray1_32f, destination, EPS);
|
||||
}
|
||||
|
||||
public void testExtractChannel() {
|
||||
@ -518,7 +518,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
des_f0.put(1, 0, 1.0);
|
||||
des_f0.put(1, 1, 2.0);
|
||||
Core.flip(src, dst, 0);
|
||||
assertMatEqual(des_f0, dst);
|
||||
assertMatEqual(des_f0, dst, EPS);
|
||||
|
||||
Mat des_f1 = new Mat(2, 2, CvType.CV_32F);
|
||||
des_f1.put(0, 0, 2.0);
|
||||
@ -526,7 +526,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
des_f1.put(1, 0, 4.0);
|
||||
des_f1.put(1, 1, 3.0);
|
||||
Core.flip(src, dst, 1);
|
||||
assertMatEqual(des_f1, dst);
|
||||
assertMatEqual(des_f1, dst, EPS);
|
||||
}
|
||||
|
||||
public void testGemmMatMatDoubleMatDoubleMat() {
|
||||
@ -548,7 +548,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
desired.put(1, 0, 1.001, 0.001);
|
||||
|
||||
Core.gemm(m1, m2, 1.0, dmatrix, 1.0, dst);
|
||||
assertMatEqual(desired, dst);
|
||||
assertMatEqual(desired, dst, EPS);
|
||||
}
|
||||
|
||||
public void testGemmMatMatDoubleMatDoubleMatInt() {
|
||||
@ -570,7 +570,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
desired.put(1, 0, 0.001, 0.001);
|
||||
|
||||
Core.gemm(m1, m2, 1.0, dmatrix, 1.0, dst, Core.GEMM_1_T);
|
||||
assertMatEqual(desired, dst);
|
||||
assertMatEqual(desired, dst, EPS);
|
||||
}
|
||||
|
||||
public void testGetCPUTickCount() {
|
||||
@ -619,7 +619,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
-0.86502546, 0.028082132, -0.7673766, 0.10917115);
|
||||
|
||||
Core.idct(in, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testIdctMatMatInt() {
|
||||
@ -631,7 +631,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
-0.86502546, 0.028082132, -0.7673766, 0.10917115);
|
||||
|
||||
Core.idct(in, dst, Core.DCT_ROWS);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testIdftMatMat() {
|
||||
@ -642,7 +642,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth.put(0, 0, 9, -9, 1, 3);
|
||||
|
||||
Core.idft(in, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testIdftMatMatInt() {
|
||||
@ -652,7 +652,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth = new Mat(1, 4, CvType.CV_32F);
|
||||
truth.put(0, 0, 9, -9, 1, 3);
|
||||
Core.idft(in, dst, Core.DFT_REAL_OUTPUT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testIdftMatMatIntInt() {
|
||||
@ -662,7 +662,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth = new Mat(1, 4, CvType.CV_32F);
|
||||
truth.put(0, 0, 9, -9, 1, 3);
|
||||
Core.idft(in, dst, Core.DFT_REAL_OUTPUT, 1);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testInRange() {
|
||||
@ -692,7 +692,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth.put(1, 1, 1.0);
|
||||
|
||||
Core.invert(src, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
|
||||
// TODO: needs epsilon comparison
|
||||
// Mat m = grayRnd_32f.clone();
|
||||
@ -707,7 +707,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth = Mat.eye(3, 3, CvType.CV_32FC1);
|
||||
|
||||
Core.invert(src, dst, Core.DECOMP_CHOLESKY);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
|
||||
Core.invert(src, dst, Core.DECOMP_LU);
|
||||
double det = Core.determinant(src);
|
||||
@ -761,7 +761,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
desired.put(0, 0, 0, 2.3025851, 4.6051702, 6.9077554);
|
||||
|
||||
Core.log(in, dst);
|
||||
assertMatEqual(desired, dst);
|
||||
assertMatEqual(desired, dst, EPS);
|
||||
}
|
||||
|
||||
public void testLUTMatMatMat() {
|
||||
@ -793,10 +793,10 @@ public class coreTest extends OpenCVTestCase {
|
||||
out.put(0, 0, 5.0, 13.0, 41.0, 10.0);
|
||||
|
||||
Core.magnitude(x, y, dst);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
|
||||
Core.magnitude(gray0_32f, gray255_32f, dst);
|
||||
assertMatEqual(gray255_32f, dst);
|
||||
assertMatEqual(gray255_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMahalanobis() {
|
||||
@ -830,7 +830,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
y.put(0, 0, 4.0);
|
||||
dst.put(0, 0, 23.0);
|
||||
Core.max(x, y, dst);
|
||||
assertMatEqual(dst, dst);
|
||||
assertMatEqual(dst, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMeanMat() {
|
||||
@ -871,7 +871,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
Core.meanStdDev(grayRnd, mean, stddev, mask);
|
||||
Mat desiredMean = new Mat(1, 1, CvType.CV_64F, new Scalar(33));
|
||||
assertMatEqual(desiredMean, mean);
|
||||
assertMatEqual(desiredMean, mean, EPS);
|
||||
assertEquals(0, Core.countNonZero(stddev));
|
||||
|
||||
Core.meanStdDev(grayRnd, mean, stddev, gray1);
|
||||
@ -924,7 +924,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
src2.put(0, 0, 1.0, 2.0, 3.0, 4.0);
|
||||
out.put(0, 0, 1, -5, 12, 16);
|
||||
Core.mulSpectrums(src1, src2, dst, Core.DFT_ROWS);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMulSpectrumsMatMatMatIntBoolean() {
|
||||
@ -935,7 +935,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
src2.put(0, 0, 1.0, 2.0, 3.0, 4.0);
|
||||
out.put(0, 0, 1, 13, 0, 16);
|
||||
Core.mulSpectrums(src1, src2, dst, Core.DFT_ROWS, true);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMultiplyMatMatMat() {
|
||||
@ -956,24 +956,24 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
public void testMulTransposedMatMatBoolean() {
|
||||
Core.mulTransposed(grayE_32f, dst, true);
|
||||
assertMatEqual(grayE_32f, dst);
|
||||
assertMatEqual(grayE_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMulTransposedMatMatBooleanMat() {
|
||||
Core.mulTransposed(grayRnd_32f, dst, true, grayRnd_32f);
|
||||
assertMatEqual(gray0_32f, dst);
|
||||
assertMatEqual(gray0_32f, dst, EPS);
|
||||
|
||||
Mat grayDelta = new Mat(matSize, matSize, CvType.CV_32F);
|
||||
grayDelta.setTo(new Scalar(0.0));
|
||||
Core.mulTransposed(grayE_32f, dst, true, grayDelta);
|
||||
assertMatEqual(grayE_32f, dst);
|
||||
assertMatEqual(grayE_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMulTransposedMatMatBooleanMatDouble() {
|
||||
Mat grayDelta = new Mat(matSize, matSize, CvType.CV_32F);
|
||||
grayDelta.setTo(new Scalar(0.0));
|
||||
Core.mulTransposed(grayE_32f, dst, true, grayDelta, 1);
|
||||
assertMatEqual(grayE_32f, dst);
|
||||
assertMatEqual(grayE_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMulTransposedMatMatBooleanMatDoubleInt() {
|
||||
@ -989,7 +989,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
res.put(2, 0, 3, 3, 3);
|
||||
|
||||
Core.mulTransposed(a, dst, true, grayDelta, 1.0, 1);
|
||||
assertMatEqual(res, dst);
|
||||
assertMatEqual(res, dst, EPS);
|
||||
}
|
||||
|
||||
public void testNormalizeMatMat() {
|
||||
@ -1013,7 +1013,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
src.put(0, 0, 1.0, 2.0, 3.0, 4.0);
|
||||
out.put(0, 0, 0.25, 0.5, 0.75, 1);
|
||||
Core.normalize(src, dst, 1.0, 2.0, Core.NORM_INF);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
}
|
||||
|
||||
public void testNormalizeMatMatDoubleDoubleIntInt() {
|
||||
@ -1024,7 +1024,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
out.put(0, 0, 0.25, 0.5, 0.75, 1);
|
||||
|
||||
Core.normalize(src, dst, 1.0, 2.0, Core.NORM_INF, -1);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
}
|
||||
|
||||
public void testNormalizeMatMatDoubleDoubleIntIntMat() {
|
||||
@ -1036,7 +1036,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
out.put(0, 0, 0.25, 0.5, 0.75, 1);
|
||||
|
||||
Core.normalize(src, dst, 1.0, 2.0, Core.NORM_INF, -1, mask);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
}
|
||||
|
||||
public void testNormMat() {
|
||||
@ -1124,7 +1124,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
res.put(0, 0, 1.1071469, 0.98280007, 0.78539175, 1.3258134);
|
||||
|
||||
Core.phase(x, y, dst);
|
||||
assertMatEqual(res, dst);
|
||||
assertMatEqual(res, dst, EPS);
|
||||
}
|
||||
|
||||
public void testPhaseMatMatMatBoolean() {
|
||||
@ -1160,7 +1160,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
// TODO: needs epsilon comparison
|
||||
Core.polarToCart(magnitude, angle, xCoordinate, yCoordinate);
|
||||
assertMatEqual(x, xCoordinate);
|
||||
assertMatEqual(x, xCoordinate, EPS);
|
||||
}
|
||||
|
||||
public void testPolarToCartMatMatMatMatBoolean() {
|
||||
@ -1279,7 +1279,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
out.put(0, 0, 1, 0);
|
||||
|
||||
Core.reduce(src, dst, 0, 2);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
}
|
||||
|
||||
public void testReduceMatMatIntIntInt() {
|
||||
@ -1291,7 +1291,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
out.put(0, 0, 1, 0);
|
||||
|
||||
Core.reduce(src, dst, 0, 2, -1);
|
||||
assertMatEqual(out, dst);
|
||||
assertMatEqual(out, dst, EPS);
|
||||
}
|
||||
|
||||
public void testRepeat() {
|
||||
@ -1304,9 +1304,9 @@ public class coreTest extends OpenCVTestCase {
|
||||
des2.put(0, 0, 1, 2, 3, 1, 2, 3);
|
||||
|
||||
Core.repeat(src, 1, 1, dst);
|
||||
assertMatEqual(des1, dst);
|
||||
assertMatEqual(des1, dst, EPS);
|
||||
Core.repeat(src, 1, 2, dst);
|
||||
assertMatEqual(des2, dst);
|
||||
assertMatEqual(des2, dst, EPS);
|
||||
}
|
||||
|
||||
public void testScaleAdd() {
|
||||
@ -1316,13 +1316,13 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
public void testSetIdentityMat() {
|
||||
Core.setIdentity(gray0_32f);
|
||||
assertMatEqual(grayE_32f, gray0_32f);
|
||||
assertMatEqual(grayE_32f, gray0_32f, EPS);
|
||||
}
|
||||
|
||||
public void testSetIdentityMatScalar() {
|
||||
Core.gemm(grayE_32f, grayE_32f, 5.0, new Mat(), 0.0, dst);
|
||||
Core.setIdentity(gray0_32f, new Scalar(5));
|
||||
assertMatEqual(dst, gray0_32f);
|
||||
assertMatEqual(dst, gray0_32f, EPS);
|
||||
}
|
||||
|
||||
public void testSolveCubic() {
|
||||
@ -1331,7 +1331,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
coeffs.put(0, 0, 1, 6, 11, 6);
|
||||
roots.put(0, 0, -3, -1, -2);
|
||||
Core.solveCubic(coeffs, dst);
|
||||
assertMatEqual(roots, dst);
|
||||
assertMatEqual(roots, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSolveMatMatMat() {
|
||||
@ -1346,7 +1346,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
res.put(0, 0, -12, 2, 10);
|
||||
|
||||
Core.solve(a, b, dst);
|
||||
assertMatEqual(res, dst);
|
||||
assertMatEqual(res, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSolveMatMatMatInt() {
|
||||
@ -1362,7 +1362,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
res.put(0, 0, -12, 2, 10);
|
||||
|
||||
Core.solve(a, b, dst, 3);
|
||||
assertMatEqual(res, dst);
|
||||
assertMatEqual(res, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSolvePolyMatMat() {
|
||||
@ -1375,7 +1375,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth.put(0, 0, 1, 0, 2, 0, 3, 0);
|
||||
|
||||
Core.solvePoly(coeffs, roots);
|
||||
assertMatEqual(truth, roots);
|
||||
assertMatEqual(truth, roots, EPS);
|
||||
}
|
||||
|
||||
public void testSolvePolyMatMatInt() {
|
||||
@ -1388,7 +1388,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
truth.put(0, 0, 1, 0, -1, 2, -2, 12);
|
||||
|
||||
Core.solvePoly(coeffs, roots, 1);
|
||||
assertMatEqual(truth, roots);
|
||||
assertMatEqual(truth, roots, EPS);
|
||||
}
|
||||
|
||||
public void testSort() {
|
||||
@ -1427,7 +1427,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
public void testSqrt() {
|
||||
Core.sqrt(gray9_32f, dst);
|
||||
assertMatEqual(gray3_32f, dst);
|
||||
assertMatEqual(gray3_32f, dst, EPS);
|
||||
|
||||
Mat rgba144 = new Mat(matSize, matSize, CvType.CV_32FC4);
|
||||
Mat rgba12 = new Mat(matSize, matSize, CvType.CV_32FC4);
|
||||
@ -1435,7 +1435,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
rgba12.setTo(Scalar.all(12));
|
||||
|
||||
Core.sqrt(rgba144, dst);
|
||||
assertMatEqual(rgba12, dst);
|
||||
assertMatEqual(rgba12, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSubtractMatMatMat() {
|
||||
@ -1456,7 +1456,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
public void testSubtractMatMatMatMatInt() {
|
||||
Core.subtract(gray3, gray2, dst, gray1, CvType.CV_32F);
|
||||
assertTrue(CvType.CV_32F == dst.depth());
|
||||
assertMatEqual(gray1_32f, dst);
|
||||
assertMatEqual(gray1_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSumElems() {
|
||||
@ -1485,7 +1485,7 @@ public class coreTest extends OpenCVTestCase {
|
||||
|
||||
Core.transform(src, dst, m);
|
||||
truth = new Mat(2, 2, CvType.CV_32FC2, new Scalar(55, 1));
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testTranspose() {
|
||||
|
||||
@ -43,18 +43,18 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
public void testAccumulateMatMat() {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_64F, new Scalar(2));
|
||||
Imgproc.accumulate(gray_64f_2, dst64F);
|
||||
assertMatEqual(truth, dst64F);
|
||||
assertMatEqual(truth, dst64F, EPS);
|
||||
|
||||
dst = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
|
||||
Imgproc.accumulate(gray1_32f, dst);
|
||||
assertMatEqual(gray1_32f, dst);
|
||||
assertMatEqual(gray1_32f, dst, EPS);
|
||||
}
|
||||
|
||||
public void testAccumulateMatMatMat() {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_64F, new Scalar(2));
|
||||
|
||||
Imgproc.accumulate(gray_64f_2, dst64F, mask); // TODO: use better mask
|
||||
assertMatEqual(truth, dst64F);
|
||||
assertMatEqual(truth, dst64F, EPS);
|
||||
}
|
||||
|
||||
public void testAccumulateProductMatMatMat() {
|
||||
@ -71,7 +71,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
Mat dstImage = new Mat(imgprocSz, imgprocSz, CvType.CV_64F, new Scalar(
|
||||
0));
|
||||
Imgproc.accumulateProduct(src1, src2, dstImage);
|
||||
assertMatEqual(truth, dstImage);
|
||||
assertMatEqual(truth, dstImage, EPS);
|
||||
}
|
||||
|
||||
public void testAccumulateProductMatMatMatMat() {
|
||||
@ -88,34 +88,34 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(1, 0, 0, 2);
|
||||
|
||||
Imgproc.accumulateProduct(src1, src2, dst64F, mask);
|
||||
assertMatEqual(truth, dst64F);
|
||||
assertMatEqual(truth, dst64F, EPS);
|
||||
}
|
||||
|
||||
public void testAccumulateSquareMatMat() {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_64F, new Scalar(4));
|
||||
|
||||
Imgproc.accumulateSquare(gray_64f_2, dst64F);
|
||||
assertMatEqual(truth, dst64F);
|
||||
assertMatEqual(truth, dst64F, EPS);
|
||||
}
|
||||
|
||||
public void testAccumulateSquareMatMatMat() {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_64F, new Scalar(4));
|
||||
|
||||
Imgproc.accumulateSquare(gray_64f_2, dst64F, mask);
|
||||
assertMatEqual(truth, dst64F);
|
||||
assertMatEqual(truth, dst64F, EPS);
|
||||
}
|
||||
|
||||
public void testAccumulateWeightedMatMatDouble() {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_64F, new Scalar(4));
|
||||
|
||||
Imgproc.accumulateWeighted(gray_64f_2, dst64F, 2.0);
|
||||
assertMatEqual(truth, dst64F);
|
||||
assertMatEqual(truth, dst64F, EPS);
|
||||
}
|
||||
|
||||
public void testAccumulateWeightedMatMatDoubleMat() {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_64F, new Scalar(8));
|
||||
Imgproc.accumulateWeighted(gray_64f_2, dst64F, 4.0, mask);
|
||||
assertMatEqual(truth, dst64F);
|
||||
assertMatEqual(truth, dst64F, EPS);
|
||||
}
|
||||
|
||||
public void testAdaptiveThreshold() {
|
||||
@ -132,7 +132,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
approxCurve.put(0, 0, 1.0, 3.0, 3.0, 5.0, 5.0, 3.0);
|
||||
|
||||
Imgproc.approxPolyDP(curve, dst, EPS, true);
|
||||
assertMatEqual(approxCurve, dst);
|
||||
assertMatEqual(approxCurve, dst, EPS);
|
||||
}
|
||||
|
||||
public void testArcLength() {
|
||||
@ -255,7 +255,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Mat hist = new Mat();
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
assertMatEqual(truth, hist);
|
||||
assertMatEqual(truth, hist, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2d() {
|
||||
@ -283,7 +283,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Mat hist = new Mat();
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges);
|
||||
assertMatEqual(truth, hist);
|
||||
assertMatEqual(truth, hist, EPS);
|
||||
}
|
||||
|
||||
public void testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloatBoolean() {
|
||||
@ -311,7 +311,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(9, 5, 100.0);
|
||||
Imgproc.calcHist(images, channels, new Mat(), hist, histSize, ranges,
|
||||
true);
|
||||
assertMatEqual(truth, hist);
|
||||
assertMatEqual(truth, hist, EPS);
|
||||
}
|
||||
|
||||
public void testCannyMatMatDoubleDouble() {
|
||||
@ -380,7 +380,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expHull.put(0, 0, 4, 0, 3, 2, 0, 2, 2, 0);
|
||||
|
||||
Imgproc.convexHull(points, dst);
|
||||
assertMatEqual(expHull, dst);
|
||||
assertMatEqual(expHull, dst, EPS);
|
||||
}
|
||||
|
||||
public void testConvexHullMatMatBoolean() {
|
||||
@ -392,7 +392,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expHull.put(0, 0, 0, 2, 3, 2, 4, 0, 2, 0);
|
||||
|
||||
Imgproc.convexHull(points, dst, true);
|
||||
assertMatEqual(expHull, dst);
|
||||
assertMatEqual(expHull, dst, EPS);
|
||||
}
|
||||
|
||||
public void testConvexHullMatMatBooleanBoolean() {
|
||||
@ -404,7 +404,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expHull.put(0, 0, 0, 2, 3, 2, 4, 0, 2, 0);
|
||||
|
||||
Imgproc.convexHull(points, dst, true, true);
|
||||
assertMatEqual(expHull, dst);
|
||||
assertMatEqual(expHull, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCopyMakeBorderMatMatIntIntIntIntInt() {
|
||||
@ -414,7 +414,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.copyMakeBorder(src, dst, border, border, border, border,
|
||||
Imgproc.BORDER_REPLICATE);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCopyMakeBorderMatMatIntIntIntIntIntScalar() {
|
||||
@ -426,7 +426,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.copyMakeBorder(src, dst, border, border, border, border,
|
||||
Imgproc.BORDER_REPLICATE, value);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerEigenValsAndVecsMatMatIntInt() {
|
||||
@ -440,7 +440,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
// TODO: eigen vals and vectors returned = 0 for most src matrices
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC(6), new Scalar(0));
|
||||
Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerEigenValsAndVecsMatMatIntIntInt() {
|
||||
@ -453,7 +453,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize,
|
||||
Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerHarrisMatMatIntIntDouble() {
|
||||
@ -462,7 +462,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
int ksize = 7;
|
||||
double k = 0.1;
|
||||
Imgproc.cornerHarris(gray128, dst, blockSize, ksize, k);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerHarrisMatMatIntIntDoubleInt() {
|
||||
@ -472,7 +472,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
double k = 0.1;
|
||||
Imgproc.cornerHarris(gray255, dst, blockSize, ksize, k,
|
||||
Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerMinEigenValMatMatInt() {
|
||||
@ -484,11 +484,11 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32FC1, new Scalar(0));
|
||||
Imgproc.cornerMinEigenVal(src, dst, blockSize);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
|
||||
Mat truth1 = new Mat(matSize, matSize, CvType.CV_32FC1, new Scalar(0));
|
||||
Imgproc.cornerMinEigenVal(gray255, dst, blockSize);
|
||||
assertMatEqual(truth1, dst);
|
||||
assertMatEqual(truth1, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerMinEigenValMatMatIntInt() {
|
||||
@ -503,7 +503,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(2, 0, 0.055555549, 0.027777772, 0.055555549);
|
||||
|
||||
Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerMinEigenValMatMatIntIntInt() {
|
||||
@ -519,7 +519,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize,
|
||||
Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testCornerSubPix() {
|
||||
@ -583,7 +583,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Mat labels = new Mat();
|
||||
Imgproc.distanceTransform(gray128, dst, labels, Imgproc.CV_DIST_L2, 3);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
assertMatEqual(dstLables, labels);
|
||||
}
|
||||
|
||||
@ -691,7 +691,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(3, 0, 0, 0, 1, 2);
|
||||
|
||||
Imgproc.filter2D(src, dst, -1, kernel);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testFilter2DMatMatIntMatPoint() {
|
||||
@ -770,7 +770,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
linePoints.put(0, 0, 0.53196341, 0.84676737, 2.496531, 3.7467217);
|
||||
|
||||
Imgproc.fitLine(points, dst, Imgproc.CV_DIST_L12, 0, 0.01, 0.01);
|
||||
assertMatEqual(linePoints, dst);
|
||||
assertMatEqual(linePoints, dst, EPS);
|
||||
}
|
||||
|
||||
public void testFloodFillMatMatPointScalar() {
|
||||
@ -872,8 +872,8 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expKy.put(0, 0, 1, -2, 1);
|
||||
|
||||
Imgproc.getDerivKernels(kx, ky, 2, 2, 3);
|
||||
assertMatEqual(expKx, kx);
|
||||
assertMatEqual(expKy, ky);
|
||||
assertMatEqual(expKx, kx, EPS);
|
||||
assertMatEqual(expKy, ky, EPS);
|
||||
}
|
||||
|
||||
public void testGetDerivKernelsMatMatIntIntIntBoolean() {
|
||||
@ -892,8 +892,8 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expKy.put(0, 0, 1, -2, 1);
|
||||
|
||||
Imgproc.getDerivKernels(kx, ky, 2, 2, 3, true);
|
||||
assertMatEqual(expKx, kx);
|
||||
assertMatEqual(expKy, ky);
|
||||
assertMatEqual(expKx, kx, EPS);
|
||||
assertMatEqual(expKy, ky, EPS);
|
||||
}
|
||||
|
||||
public void testGetDerivKernelsMatMatIntIntIntBooleanInt() {
|
||||
@ -912,15 +912,15 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expKy.put(0, 0, 1, -2, 1);
|
||||
|
||||
Imgproc.getDerivKernels(kx, ky, 2, 2, 3, true, CvType.CV_32F);
|
||||
assertMatEqual(expKx, kx);
|
||||
assertMatEqual(expKy, ky);
|
||||
assertMatEqual(expKx, kx, EPS);
|
||||
assertMatEqual(expKy, ky, EPS);
|
||||
}
|
||||
|
||||
public void testGetGaussianKernelIntDouble() {
|
||||
truth = new Mat(1, 1, CvType.CV_64FC1, new Scalar(1.0));
|
||||
|
||||
dst = Imgproc.getGaussianKernel(1, 0.5);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testGetGaussianKernelIntDoubleInt() {
|
||||
@ -928,7 +928,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(0, 0, 0.23899426, 0.52201146, 0.23899426);
|
||||
|
||||
dst = Imgproc.getGaussianKernel(3, 0.8, CvType.CV_32F);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testGetRectSubPixMatSizePointMat() {
|
||||
@ -947,7 +947,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
Point center = new Point(src.cols() / 2, src.rows() / 2);
|
||||
|
||||
Imgproc.getRectSubPix(src, patchSize, center, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testGetRotationMatrix2D() {
|
||||
@ -956,7 +956,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(1, 0, 0, 1, 0);
|
||||
Point center = new Point(0, 0);
|
||||
dst = Imgproc.getRotationMatrix2D(center, 0.0, 1.0);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testGetStructuringElementIntSize() {
|
||||
@ -1135,8 +1135,8 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expSqsum.put(3, 0, 0, 27, 54, 81);
|
||||
|
||||
Imgproc.integral2(src, sum, sqsum);
|
||||
assertMatEqual(expSum, sum);
|
||||
assertMatEqual(expSqsum, sqsum);
|
||||
assertMatEqual(expSum, sum, EPS);
|
||||
assertMatEqual(expSqsum, sqsum, EPS);
|
||||
}
|
||||
|
||||
public void testIntegral2MatMatMatInt() {
|
||||
@ -1157,8 +1157,8 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expSqsum.put(3, 0, 0, 27, 54, 81);
|
||||
|
||||
Imgproc.integral2(src, sum, sqsum, CvType.CV_64F);
|
||||
assertMatEqual(expSum, sum);
|
||||
assertMatEqual(expSqsum, sqsum);
|
||||
assertMatEqual(expSum, sum, EPS);
|
||||
assertMatEqual(expSqsum, sqsum, EPS);
|
||||
}
|
||||
|
||||
public void testIntegral3MatMatMatMat() {
|
||||
@ -1180,9 +1180,9 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expTilted.put(1, 0, 0, 1);
|
||||
|
||||
Imgproc.integral3(src, sum, sqsum, tilted);
|
||||
assertMatEqual(expSum, sum);
|
||||
assertMatEqual(expSqsum, sqsum);
|
||||
assertMatEqual(expTilted, tilted);
|
||||
assertMatEqual(expSum, sum, EPS);
|
||||
assertMatEqual(expSqsum, sqsum, EPS);
|
||||
assertMatEqual(expTilted, tilted, EPS);
|
||||
|
||||
}
|
||||
|
||||
@ -1205,9 +1205,9 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
expTilted.put(1, 0, 0, 1);
|
||||
|
||||
Imgproc.integral3(src, sum, sqsum, tilted, CvType.CV_64F);
|
||||
assertMatEqual(expSum, sum);
|
||||
assertMatEqual(expSqsum, sqsum);
|
||||
assertMatEqual(expTilted, tilted);
|
||||
assertMatEqual(expSum, sum, EPS);
|
||||
assertMatEqual(expSqsum, sqsum, EPS);
|
||||
assertMatEqual(expTilted, tilted, EPS);
|
||||
}
|
||||
|
||||
public void testIntegralMatMat() {
|
||||
@ -1219,7 +1219,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(2, 0, 0, 4, 8);
|
||||
|
||||
Imgproc.integral(src, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
|
||||
}
|
||||
|
||||
@ -1232,7 +1232,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(2, 0, 0, 4, 8);
|
||||
|
||||
Imgproc.integral(src, dst, CvType.CV_64F);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testInvertAffineTransform() {
|
||||
@ -1240,7 +1240,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth = new Mat(2, 3, CvType.CV_64F, new Scalar(0));
|
||||
|
||||
Imgproc.invertAffineTransform(src, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testIsContourConvex() {
|
||||
@ -1263,7 +1263,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth = new Mat(3, 3, CvType.CV_32F, new Scalar(0.0));
|
||||
|
||||
Imgproc.Laplacian(src, dst, CvType.CV_32F, 1);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testLaplacianMatMatIntIntDouble() {
|
||||
@ -1275,7 +1275,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(1, 0, 8, -8);
|
||||
|
||||
Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2.0);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testLaplacianMatMatIntIntDoubleDouble() {
|
||||
@ -1287,7 +1287,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(1, 0, 8.0009995, -7.9990001);
|
||||
|
||||
Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2.0, EPS);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testLaplacianMatMatIntIntDoubleDoubleInt() {
|
||||
@ -1296,7 +1296,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2.0, EPS,
|
||||
Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMatchShapes() {
|
||||
@ -1322,11 +1322,11 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
truth = new Mat(1, 1, CvType.CV_32F, new Scalar(70));
|
||||
Imgproc.matchTemplate(image, templ, dst, Imgproc.TM_CCORR);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
|
||||
truth = new Mat(1, 1, CvType.CV_32F, new Scalar(0));
|
||||
Imgproc.matchTemplate(gray255, gray0, dst, Imgproc.TM_CCORR);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testMedianBlur() {
|
||||
@ -1451,7 +1451,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
int ksize = 3;
|
||||
|
||||
Imgproc.preCornerDetect(src, dst, ksize);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testPreCornerDetectMatMatIntInt() {
|
||||
@ -1460,7 +1460,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
int ksize = 3;
|
||||
|
||||
Imgproc.preCornerDetect(src, dst, ksize, Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testPyrDownMatMat() {
|
||||
@ -1475,7 +1475,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F);
|
||||
truth.put(0, 0, 2.78125, 4.609375);
|
||||
truth.put(1, 0, 8.546875, 8.8515625);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testPyrDownMatMatSize() {
|
||||
@ -1492,7 +1492,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(1, 0, 8.546875, 8.8515625);
|
||||
|
||||
Imgproc.pyrDown(src, dst, dstSize);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testPyrMeanShiftFilteringMatMatDoubleDouble() {
|
||||
@ -1522,7 +1522,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(3, 0, 2.25, 2, 1.625, 1.5);
|
||||
|
||||
Imgproc.pyrUp(src, dst);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testPyrUpMatMatSize() {
|
||||
@ -1538,7 +1538,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(3, 0, 2.25, 2, 1.625, 1.5);
|
||||
|
||||
Imgproc.pyrUp(src, dst, dstSize);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testRemapMatMatMatMatInt() {
|
||||
@ -1552,7 +1552,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth = new Mat(1, 3, CvType.CV_32F, new Scalar(0));
|
||||
|
||||
Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testRemapMatMatMatMatIntInt() {
|
||||
@ -1567,7 +1567,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR,
|
||||
Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testRemapMatMatMatMatIntIntScalar() {
|
||||
@ -1584,7 +1584,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR,
|
||||
Imgproc.BORDER_REFLECT, sc);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testResizeMatMatSize() {
|
||||
@ -1625,7 +1625,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
|
||||
Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testScharrMatMatIntIntIntDouble() {
|
||||
@ -1633,7 +1633,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
|
||||
Imgproc.Scharr(src, dst, CvType.CV_32F, 0, 1, 1.5);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testScharrMatMatIntIntIntDoubleDouble() {
|
||||
@ -1641,7 +1641,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0.001));
|
||||
Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0.001);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testScharrMatMatIntIntIntDoubleDoubleInt() {
|
||||
@ -1654,7 +1654,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0.0,
|
||||
Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSepFilter2DMatMatIntMatMat() {
|
||||
@ -1667,7 +1667,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
kernelY.put(0, 0, 9.0, 4.0, 2.0);
|
||||
|
||||
Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSepFilter2DMatMatIntMatMatPoint() {
|
||||
@ -1682,7 +1682,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY,
|
||||
anchorPoint);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSepFilter2DMatMatIntMatMatPointDouble() {
|
||||
@ -1698,7 +1698,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(36.001));
|
||||
Imgproc.sepFilter2D(src, dst, CvType.CV_32F, kernelX, kernelY,
|
||||
anchorPoint, EPS);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSepFilter2DMatMatIntMatMatPointDoubleInt() {
|
||||
@ -1711,7 +1711,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth = new Mat(10, 10, CvType.CV_32F, new Scalar(0.001));
|
||||
Imgproc.sepFilter2D(gray0, dst, CvType.CV_32F, kernelX, kernelY,
|
||||
anchorPoint, EPS, Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSobelMatMatIntIntInt() {
|
||||
@ -1736,8 +1736,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(2, 0, 0, -24, 0);
|
||||
|
||||
Imgproc.Sobel(src, dst, CvType.CV_32F, 1, 0, 3, 2.0);
|
||||
assertMatEqual(truth, dst);
|
||||
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testSobelMatMatIntIntIntIntDoubleDouble() {
|
||||
@ -1758,7 +1757,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.Sobel(src, dst, CvType.CV_32F, 1, 0, 3, 2.0, 0.0,
|
||||
Imgproc.BORDER_REPLICATE);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testThreshold() {
|
||||
@ -1790,7 +1789,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(2, 0, 0, 3, 0);
|
||||
|
||||
Imgproc.undistort(src, dst, cameraMatrix, distCoeffs);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testUndistortMatMatMatMatMat() {
|
||||
@ -1809,7 +1808,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth = new Mat(3, 3, CvType.CV_32F, new Scalar(3));
|
||||
|
||||
Imgproc.undistort(src, dst, cameraMatrix, distCoeffs, newCameraMatrix);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpAffineMatMatMatSize() {
|
||||
@ -1830,7 +1829,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
M.put(1, 0, 0, 1, 1);
|
||||
|
||||
Imgproc.warpAffine(src, dst, M, size);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpAffineMatMatMatSizeInt() {
|
||||
@ -1850,7 +1849,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
M.put(1, 0, 0, 0, 1);
|
||||
|
||||
Imgproc.warpAffine(src, dst, M, dsize, Imgproc.WARP_INVERSE_MAP);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpAffineMatMatMatSizeIntInt() {
|
||||
@ -1869,7 +1868,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.warpAffine(src, dst, M, dsize, Imgproc.WARP_INVERSE_MAP,
|
||||
Imgproc.BORDER_TRANSPARENT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpAffineMatMatMatSizeIntIntScalar() {
|
||||
@ -1891,7 +1890,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.warpAffine(src, dst, M, dsize, Imgproc.WARP_INVERSE_MAP,
|
||||
Imgproc.BORDER_CONSTANT, sc);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpPerspectiveMatMatMatSize() {
|
||||
@ -1912,7 +1911,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(2, 0, 0, 0, 4);
|
||||
|
||||
Imgproc.warpPerspective(src, dst, M, size);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpPerspectiveMatMatMatSizeInt() {
|
||||
@ -1932,8 +1931,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
truth.put(1, 0, 6, 4);
|
||||
|
||||
Imgproc.warpPerspective(src, dst, M, dsize, Imgproc.WARP_INVERSE_MAP);
|
||||
assertMatEqual(truth, dst);
|
||||
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpPerspectiveMatMatMatSizeIntInt() {
|
||||
@ -1954,7 +1952,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.warpPerspective(src, dst, M, dsize, Imgproc.WARP_INVERSE_MAP,
|
||||
Imgproc.BORDER_REFLECT);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWarpPerspectiveMatMatMatSizeIntIntScalar() {
|
||||
@ -1973,7 +1971,7 @@ public class imgprocTest extends OpenCVTestCase {
|
||||
|
||||
Imgproc.warpPerspective(src, dst, M, dsize, Imgproc.WARP_INVERSE_MAP,
|
||||
Imgproc.BORDER_REFLECT, sc);
|
||||
assertMatEqual(truth, dst);
|
||||
assertMatEqual(truth, dst, EPS);
|
||||
}
|
||||
|
||||
public void testWatershed() {
|
||||
|
||||
@ -426,6 +426,13 @@ JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_nInv
|
||||
return (jlong) new cv::Mat(me->inv());
|
||||
}
|
||||
|
||||
JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_nReshape
|
||||
(JNIEnv* env, jclass cls, jlong self, jint cn, jint rows)
|
||||
{
|
||||
cv::Mat* me = (cv::Mat*) self; //TODO: check for NULL
|
||||
return (jlong) new cv::Mat(me->reshape(cn, rows));
|
||||
}
|
||||
|
||||
JNIEXPORT jlong JNICALL Java_org_opencv_core_Mat_nCreateMat__
|
||||
(JNIEnv* env, jclass cls)
|
||||
{
|
||||
|
||||
@ -276,6 +276,16 @@ public class Mat {
|
||||
return new Mat( nInv(nativeObj) );
|
||||
}
|
||||
|
||||
//javadoc:Mat::reshape(cn)
|
||||
public Mat reshape(int cn) {
|
||||
return new Mat( nReshape(nativeObj, cn, 0) );
|
||||
}
|
||||
|
||||
//javadoc:Mat::reshape(cn, rows)
|
||||
public Mat reshape(int cn, int rows) {
|
||||
return new Mat( nReshape(nativeObj, cn, rows) );
|
||||
}
|
||||
|
||||
//javadoc:Mat::getNativeObjAddr()
|
||||
public long getNativeObjAddr() {
|
||||
return nativeObj;
|
||||
@ -315,6 +325,7 @@ public class Mat {
|
||||
private static native double nDot(long self, long mat);
|
||||
private static native long nCross(long self, long mat);
|
||||
private static native long nInv(long self);
|
||||
private static native long nReshape(long self, int cn, int rows);
|
||||
private static native long nEye(int rows, int cols, int type);
|
||||
private static native String nDump(long self);
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user