From ebb08bc0153b9f51aa025c14ec36ea1dd7387f8b Mon Sep 17 00:00:00 2001 From: Andrey Kamaev Date: Wed, 10 Aug 2011 15:56:47 +0000 Subject: [PATCH] Java API: Fixed bug in Mat port; fixed/implemented all java tests for core module --- .../src/org/opencv/test/OpenCVTestCase.java | 9 +- .../src/org/opencv/test/core/CoreTest.java | 23 ++- .../src/org/opencv/test/core/MatTest.java | 183 ++++++++++++++++-- .../org/opencv/test/core/RotatedRectTest.java | 22 ++- modules/java/src/cpp/Mat.cpp | 18 +- modules/java/src/java/core+Mat.java | 10 +- 6 files changed, 217 insertions(+), 48 deletions(-) diff --git a/modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java b/modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java index 455a2e47e1..191f5ee34e 100644 --- a/modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java +++ b/modules/java/android_test/src/org/opencv/test/OpenCVTestCase.java @@ -18,6 +18,7 @@ import org.opencv.core.Point; import org.opencv.core.Point3; import org.opencv.core.Rect; import org.opencv.core.Scalar; +import org.opencv.core.Size; import org.opencv.features2d.DMatch; import org.opencv.features2d.KeyPoint; import org.opencv.highgui.Highgui; @@ -307,7 +308,13 @@ public class OpenCVTestCase extends TestCase { assertEquals(msg, expected.x, actual.x, eps); assertEquals(msg, expected.y, actual.y, eps); } - + + public static void assertSizeEquals(Size expected, Size actual, double eps) { + String msg = "expected:<" + expected + "> but was:<" + actual + ">"; + assertEquals(msg, expected.width, actual.width, eps); + assertEquals(msg, expected.height, actual.height, eps); + } + public static void assertPoint3Equals(Point3 expected, Point3 actual, double eps) { String msg = "expected:<" + expected + "> but was:<" + actual + ">"; assertEquals(msg, expected.x, actual.x, eps); diff --git a/modules/java/android_test/src/org/opencv/test/core/CoreTest.java b/modules/java/android_test/src/org/opencv/test/core/CoreTest.java index 317ba9d482..71fe5fb9c9 100644 --- a/modules/java/android_test/src/org/opencv/test/core/CoreTest.java +++ b/modules/java/android_test/src/org/opencv/test/core/CoreTest.java @@ -16,6 +16,7 @@ import org.opencv.core.Scalar; import org.opencv.core.Size; import org.opencv.core.TermCriteria; import org.opencv.test.OpenCVTestCase; +import org.opencv.test.OpenCVTestRunner; public class CoreTest extends OpenCVTestCase { @@ -33,17 +34,11 @@ public class CoreTest extends OpenCVTestCase { public void testAddMatMatMatMat() { Mat mask = makeMask(gray1.clone()); + dst = gray127.clone(); Core.add(gray127, gray1, dst, mask); assertMatEqual(makeMask(gray128, 127), dst); - - // FIXME: https://code.ros.org/trac/opencv/ticket/1286 - /* - * dst is uninitialized => add allocates it 2) left half of mask is zeor - * => add do not assign it 3) so left part of dst remains uninitialized - * => filled with random junk values - */ } public void testAddMatMatMatMatInt() { @@ -735,16 +730,19 @@ public class CoreTest extends OpenCVTestCase { } public void testFillConvexPolyMatListOfPointScalarIntInt() { - List polyline1 = Arrays.asList(new Point(1, 1), new Point(5, 1), new Point(5, 8), new Point(1, 8)); - List polyline2 = Arrays.asList(new Point(2, 2), new Point(10, 2), new Point(10, 16), new Point(2, 16)); - // FIXME: https://code.ros.org/trac/opencv/ticket/1284 + List polyline1 = Arrays.asList(new Point(2, 1), new Point(5, 1), new Point(5, 7), new Point(2, 7)); + List polyline2 = Arrays.asList(new Point(4, 2), new Point(10, 2), new Point(10, 14), new Point(4, 14)); + // current implementation of fixed-point version of fillConvexPoly + // requires image to be at least 2-pixel wider in each direction than + // contour Core.fillConvexPoly(gray0, polyline1, colorWhite, Core.LINE_8, 0); assertTrue(0 < Core.countNonZero(gray0)); assertTrue(gray0.total() > Core.countNonZero(gray0)); Core.fillConvexPoly(gray0, polyline2, colorBlack, Core.LINE_8, 1); + OpenCVTestRunner.Log(gray0); assertEquals("see https://code.ros.org/trac/opencv/ticket/1284", 0, Core.countNonZero(gray0)); } @@ -1632,9 +1630,10 @@ public class CoreTest extends OpenCVTestCase { put(0, 0, 1, 0, 0, 0, 1); } }; + dst = src.clone(); Core.normalize(src, dst, 1, 2, Core.NORM_MINMAX, CvType.CV_32F, mask); - // FIXME: https://code.ros.org/trac/opencv/ticket/1286 + Mat expected = new Mat(1, 5, CvType.CV_32F) { { put(0, 0, 1, 1, 2, 3, 2); @@ -2356,11 +2355,11 @@ public class CoreTest extends OpenCVTestCase { public void testSubtractMatMatMatMat() { Mat mask = makeMask(gray1.clone()); + dst = gray128.clone(); Core.subtract(gray128, gray1, dst, mask); assertMatEqual(makeMask(gray127, 128), dst); - // FIXME: https://code.ros.org/trac/opencv/ticket/1286 } public void testSubtractMatMatMatMatInt() { diff --git a/modules/java/android_test/src/org/opencv/test/core/MatTest.java b/modules/java/android_test/src/org/opencv/test/core/MatTest.java index 1c6ee9439c..ed0623b238 100644 --- a/modules/java/android_test/src/org/opencv/test/core/MatTest.java +++ b/modules/java/android_test/src/org/opencv/test/core/MatTest.java @@ -4,6 +4,7 @@ import org.opencv.core.Core; import org.opencv.core.CvException; import org.opencv.core.CvType; import org.opencv.core.Mat; +import org.opencv.core.Point; import org.opencv.core.Range; import org.opencv.core.Rect; import org.opencv.core.Scalar; @@ -15,19 +16,38 @@ import java.util.Arrays; public class MatTest extends OpenCVTestCase { public void testAdjustROI() { - fail("Not yet implemented"); + Mat roi = gray0.submat(3, 5, 7, 10); + Mat originalroi = roi.clone(); + + Mat adjusted = roi.adjustROI(2, 2, 2, 2); + + assertMatEqual(adjusted, roi); + assertSizeEquals(new Size(5, 6), adjusted.size(), EPS); + assertEquals(originalroi.type(), adjusted.type()); + assertTrue(adjusted.isSubmatrix()); + assertFalse(adjusted.isContinuous()); + + Point offset = new Point(); + Size size = new Size(); + adjusted.locateROI(size, offset); + assertPointEquals(new Point(5, 1), offset, EPS); + assertSizeEquals(gray0.size(), size, EPS); } public void testAssignToMat() { gray0.assignTo(dst); + assertMatEqual(gray0, dst); gray255.assignTo(dst); + assertMatEqual(gray255, dst); } public void testAssignToMatInt() { - fail("Not yet implemented"); + gray255.assignTo(dst, CvType.CV_32F); + + assertMatEqual(gray255_32f, dst, EPS); } public void testChannels() { @@ -39,15 +59,36 @@ public class MatTest extends OpenCVTestCase { public void testCheckVectorInt() { // ! returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel // (1 x N) or (N x 1); negative number otherwise - fail("Not yet implemented"); + assertEquals(2, new Mat(2, 10, CvType.CV_8U).checkVector(10)); + assertEquals(2, new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10)); + assertEquals(2, new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10)); + assertEquals(2, new Mat(1, 10, CvType.CV_8UC2).checkVector(10)); + + assertTrue(0 > new Mat().checkVector(0)); + assertTrue(0 > new Mat(10, 1, CvType.CV_8U).checkVector(10)); + assertTrue(0 > new Mat(10, 20, CvType.CV_8U).checkVector(10)); } public void testCheckVectorIntInt() { - fail("Not yet implemented"); + assertEquals(2, new Mat(2, 10, CvType.CV_8U).checkVector(10, CvType.CV_8U)); + assertEquals(2, new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8U)); + assertEquals(2, new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8U)); + assertEquals(2, new Mat(1, 10, CvType.CV_8UC2).checkVector(10, CvType.CV_8U)); + + assertTrue(0 > new Mat(2, 10, CvType.CV_8U).checkVector(10, CvType.CV_8S)); + assertTrue(0 > new Mat(1, 2, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8S)); + assertTrue(0 > new Mat(2, 1, CvType.CV_8UC(10)).checkVector(10, CvType.CV_8S)); + assertTrue(0 > new Mat(1, 10, CvType.CV_8UC2).checkVector(10, CvType.CV_8S)); } public void testCheckVectorIntIntBoolean() { - fail("Not yet implemented"); + Mat mm = new Mat(5, 1, CvType.CV_8UC(10)); + Mat roi = new Mat(5, 3, CvType.CV_8UC(10)).submat(1, 3, 2, 3); + + assertEquals(5, mm.checkVector(10, CvType.CV_8U, true)); + assertEquals(5, mm.checkVector(10, CvType.CV_8U, false)); + assertEquals(2, roi.checkVector(10, CvType.CV_8U, false)); + assertTrue(0 > roi.checkVector(10, CvType.CV_8U, true)); } public void testClone() { @@ -202,7 +243,7 @@ public class MatTest extends OpenCVTestCase { public void testElemSize() { assertEquals(Byte.SIZE / 8 * gray0.channels(), gray0.elemSize()); - assertEquals(Double.SIZE / 8 * gray0_32f.channels(), gray0_32f.elemSize()); + assertEquals(Float.SIZE / 8 * gray0_32f.channels(), gray0_32f.elemSize()); assertEquals(Byte.SIZE / 8 * rgbLena.channels(), rgbLena.elemSize()); } @@ -303,9 +344,27 @@ public class MatTest extends OpenCVTestCase { } public void testInvInt() { - fail("Not yet implemented"); - dst = gray0_32f.inv(Core.DECOMP_CHOLESKY); - assertMatEqual(gray0_32f, dst, EPS); + Mat src = new Mat(2, 2, CvType.CV_32F) { + { + put(0, 0, 1.0); + put(0, 1, 2.0); + put(1, 0, 1.5); + put(1, 1, 4.0); + } + }; + + dst = src.inv(Core.DECOMP_CHOLESKY); + + truth = new Mat(2, 2, CvType.CV_32F) { + { + put(0, 0, 4.0); + put(0, 1, -2.0); + put(1, 0, -1.5); + put(1, 1, 1.0); + } + }; + + assertMatEqual(truth, dst, EPS); } public void testIsContinuous() { @@ -322,7 +381,14 @@ public class MatTest extends OpenCVTestCase { } public void testLocateROI() { - fail("Not yet implemented"); + Mat roi = gray0.submat(3, 5, 7, 10); + Point offset = new Point(); + Size size = new Size(); + + roi.locateROI(size, offset); + + assertPointEquals(new Point(7, 3), offset, EPS); + assertSizeEquals(new Size(10, 10), size, EPS); } public void testMat() { @@ -462,7 +528,17 @@ public class MatTest extends OpenCVTestCase { } public void testPutIntIntByteArray() { - fail("Not yet implemented"); + Mat m = new Mat(5, 5, CvType.CV_8UC3); + byte[] bytes = new byte[] { 10, 20, 30, 40, 50, 60 }; + m.put(1, 1, bytes); + + try { + byte[] bytes2 = new byte[] { 10, 20, 30, 40, 50 }; + m.put(2, 2, bytes2); + fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)"); + } catch (UnsupportedOperationException e) { + // expected + } } public void testPutIntIntDoubleArray() { @@ -478,15 +554,45 @@ public class MatTest extends OpenCVTestCase { } public void testPutIntIntFloatArray() { - fail("Not yet implemented"); + Mat m = new Mat(5, 5, CvType.CV_32FC3); + float[] elements = new float[] { 10, 20, 30, 40, 50, 60 }; + m.put(1, 1, elements); + + try { + float[] elements2 = new float[] { 10, 20, 30, 40, 50 }; + m.put(2, 2, elements2); + fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)"); + } catch (UnsupportedOperationException e) { + // expected + } } public void testPutIntIntIntArray() { - fail("Not yet implemented"); + Mat m = new Mat(5, 5, CvType.CV_32SC3); + int[] elements = new int[] { 10, 20, 30, 40, 50, 60 }; + m.put(1, 1, elements); + + try { + int[] elements2 = new int[] { 10, 20, 30, 40, 50 }; + m.put(2, 2, elements2); + fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)"); + } catch (UnsupportedOperationException e) { + // expected + } } public void testPutIntIntShortArray() { - fail("Not yet implemented"); + Mat m = new Mat(5, 5, CvType.CV_16SC3); + short[] elements = new short[] { 10, 20, 30, 40, 50, 60 }; + m.put(1, 1, elements); + + try { + short[] elements2 = new short[] { 10, 20, 30, 40, 50 }; + m.put(2, 2, elements2); + fail("Expected UnsupportedOperationException (data.length % CvType.channels(t) != 0)"); + } catch (UnsupportedOperationException e) { + // expected + } } public void testRelease() { @@ -523,7 +629,6 @@ public class MatTest extends OpenCVTestCase { } public void testRowRangeIntInt() { - fail("Not yet implemented"); Mat rows = gray0.rowRange(0, gray0.rows() / 2); assertEquals(gray0.rows() / 2, rows.rows()); assertEquals(gray0.cols(), rows.cols()); @@ -541,11 +646,45 @@ public class MatTest extends OpenCVTestCase { } public void testSetToMat() { - fail("Not yet implemented"); + Mat vals = new Mat(7, 1, CvType.CV_8U) { + { + put(0, 0, 1, 2, 3, 4, 5, 6, 7); + } + }; + Mat dst = new Mat(1, 1, CvType.CV_8UC(7)); + + dst.setTo(vals); + + Mat truth = new Mat(1, 1, CvType.CV_8UC(7)) { + { + put(0, 0, 1, 2, 3, 4, 5, 6, 7); + } + }; + assertMatEqual(truth, dst); } public void testSetToMatMat() { - fail("Not yet implemented"); + Mat vals = new Mat(7, 1, CvType.CV_8U) { + { + put(0, 0, 1, 2, 3, 4, 5, 6, 7); + } + }; + Mat dst = Mat.zeros(2, 1, CvType.CV_8UC(7)); + Mat mask = new Mat(2, 1, CvType.CV_8U) { + { + put(0, 0, 0, 1); + } + }; + + dst.setTo(vals, mask); + + Mat truth = new Mat(2, 1, CvType.CV_8UC(7)) { + { + put(0, 0, 0, 0, 0, 0, 0, 0, 0); + put(1, 0, 1, 2, 3, 4, 5, 6, 7); + } + }; + assertMatEqual(truth, dst); } public void testSetToScalar() { @@ -560,13 +699,19 @@ public class MatTest extends OpenCVTestCase { } public void testStep1() { - assertEquals(10, gray0.step1()); + assertEquals(matSize * CvType.channels(CvType.CV_8U), gray0.step1()); assertEquals(3, v2.step1()); } public void testStep1Int() { - fail("Not yet implemented"); + Mat roi = rgba0.submat(3, 5, 7, 10); + Mat m = roi.clone(); + + assertEquals(rgba0.channels() * rgba0.cols(), roi.step1(0)); + assertEquals(rgba0.channels(), roi.step1(1)); + assertEquals(rgba0.channels() * (10 - 7), m.step1(0)); + assertEquals(rgba0.channels(), m.step1(1)); } public void testSubmatIntIntIntInt() { diff --git a/modules/java/android_test/src/org/opencv/test/core/RotatedRectTest.java b/modules/java/android_test/src/org/opencv/test/core/RotatedRectTest.java index 2602b51d9c..fc215fc661 100644 --- a/modules/java/android_test/src/org/opencv/test/core/RotatedRectTest.java +++ b/modules/java/android_test/src/org/opencv/test/core/RotatedRectTest.java @@ -163,11 +163,27 @@ public class RotatedRectTest extends OpenCVTestCase { } public void testSet() { - fail("Not yet implemented"); + double[] vals1 = {}; + RotatedRect r1 = new RotatedRect(center, size, 40); + + r1.set(vals1); + + assertEquals(0., r1.angle); + assertPointEquals(new Point(0, 0), r1.center, EPS); + assertSizeEquals(new Size(0, 0), r1.size, EPS); + + double[] vals2 = { 1, 2, 3, 4, 5 }; + RotatedRect r2 = new RotatedRect(center, size, 40); + + r2.set(vals2); + + assertEquals(5., r2.angle); + assertPointEquals(new Point(1, 2), r2.center, EPS); + assertSizeEquals(new Size(3, 4), r2.size, EPS); } - + public void testToString() { - String actual = new RotatedRect(new Point(1,2), new Size(10,12), 4.5).toString(); + String actual = new RotatedRect(new Point(1, 2), new Size(10, 12), 4.5).toString(); String expected = "{ {1.0, 2.0} 10x12 * 4.5 }"; assertEquals(expected, actual); } diff --git a/modules/java/src/cpp/Mat.cpp b/modules/java/src/cpp/Mat.cpp index 6081deda0f..98b7ed9df7 100644 --- a/modules/java/src/cpp/Mat.cpp +++ b/modules/java/src/cpp/Mat.cpp @@ -1174,27 +1174,27 @@ JNIEXPORT jboolean JNICALL Java_org_opencv_core_Mat_n_1isSubmatrix // -JNIEXPORT void JNICALL Java_org_opencv_core_Mat_n_1locateROI - (JNIEnv* env, jclass cls, jlong self, jdouble wholeSize_width, jdouble wholeSize_height, jdouble ofs_x, jdouble ofs_y) +JNIEXPORT void JNICALL Java_org_opencv_core_Mat_locateROI_10 + (JNIEnv* env, jclass cls, jlong self, jdoubleArray wholeSize_out, jdoubleArray ofs_out) { try { - LOGD("Mat::n_1locateROI()"); + LOGD("core::locateROI_10()"); Mat* me = (Mat*) self; //TODO: check for NULL - Size wholeSize((int)wholeSize_width, (int)wholeSize_height); - Point ofs((int)ofs_x, (int)ofs_y); + Size wholeSize; + Point ofs; me->locateROI( wholeSize, ofs ); - + jdouble tmp_wholeSize[2] = {wholeSize.width, wholeSize.height}; env->SetDoubleArrayRegion(wholeSize_out, 0, 2, tmp_wholeSize); jdouble tmp_ofs[2] = {ofs.x, ofs.y}; env->SetDoubleArrayRegion(ofs_out, 0, 2, tmp_ofs); return; } catch(cv::Exception e) { - LOGD("Mat::n_1locateROI() catched cv::Exception: %s", e.what()); + LOGD("Mat::locateROI_10() catched cv::Exception: %s", e.what()); jclass je = env->FindClass("org/opencv/core/CvException"); if(!je) je = env->FindClass("java/lang/Exception"); env->ThrowNew(je, e.what()); return; } catch (...) { - LOGD("Mat::n_1locateROI() catched unknown exception (...)"); + LOGD("Mat::locateROI_10() catched unknown exception (...)"); jclass je = env->FindClass("java/lang/Exception"); - env->ThrowNew(je, "Unknown exception in JNI code {Mat::n_1locateROI()}"); + env->ThrowNew(je, "Unknown exception in JNI code {Mat::locateROI_10()}"); return; } } diff --git a/modules/java/src/java/core+Mat.java b/modules/java/src/java/core+Mat.java index a839d09de6..3943380795 100644 --- a/modules/java/src/java/core+Mat.java +++ b/modules/java/src/java/core+Mat.java @@ -549,9 +549,11 @@ public class Mat { // javadoc: Mat::locateROI(wholeSize, ofs) public void locateROI(Size wholeSize, Point ofs) { - - n_locateROI(nativeObj, wholeSize.width, wholeSize.height, ofs.x, ofs.y); - + double[] wholeSize_out = new double[2]; + double[] ofs_out = new double[2]; + locateROI_0(nativeObj, wholeSize_out, ofs_out); + if(wholeSize!=null){ wholeSize.width = wholeSize_out[0]; wholeSize.height = wholeSize_out[1]; } + if(ofs!=null){ ofs.x = ofs_out[0]; ofs.y = ofs_out[1]; } return; } @@ -1190,7 +1192,7 @@ public class Mat { private static native boolean n_isSubmatrix(long nativeObj); // C++: void Mat::locateROI(Size wholeSize, Point ofs) - private static native void n_locateROI(long nativeObj, double wholeSize_width, double wholeSize_height, double ofs_x, double ofs_y); + private static native void locateROI_0(long nativeObj, double[] wholeSize_out, double[] ofs_out); // C++: Mat Mat::mul(Mat m, double scale = 1) private static native long n_mul(long nativeObj, long m_nativeObj, double scale);