Modified java wrapping mechanism

modules/core/misc/java/test/CvTypeTest.java

@@ -0,0 +1,63 @@
+package org.opencv.test.core;
+
+import org.opencv.core.CvType;
+import org.opencv.test.OpenCVTestCase;
+
+public class CvTypeTest extends OpenCVTestCase {
+
+    public void testMakeType() {
+        assertEquals(CvType.CV_8UC4, CvType.makeType(CvType.CV_8U, 4));
+    }
+
+    public void testCV_8UC() {
+        assertEquals(CvType.CV_8UC4, CvType.CV_8UC(4));
+    }
+
+    public void testCV_8SC() {
+        assertEquals(CvType.CV_8SC4, CvType.CV_8SC(4));
+    }
+
+    public void testCV_16UC() {
+        assertEquals(CvType.CV_16UC4, CvType.CV_16UC(4));
+    }
+
+    public void testCV_16SC() {
+        assertEquals(CvType.CV_16SC4, CvType.CV_16SC(4));
+    }
+
+    public void testCV_32SC() {
+        assertEquals(CvType.CV_32SC4, CvType.CV_32SC(4));
+    }
+
+    public void testCV_32FC() {
+        assertEquals(CvType.CV_32FC4, CvType.CV_32FC(4));
+    }
+
+    public void testCV_64FC() {
+        assertEquals(CvType.CV_64FC4, CvType.CV_64FC(4));
+    }
+
+    public void testChannels() {
+        assertEquals(1, CvType.channels(CvType.CV_64F));
+    }
+
+    public void testDepth() {
+        assertEquals(CvType.CV_64F, CvType.depth(CvType.CV_64FC3));
+    }
+
+    public void testIsInteger() {
+        assertFalse(CvType.isInteger(CvType.CV_32FC3));
+        assertTrue(CvType.isInteger(CvType.CV_16S));
+    }
+
+    public void testELEM_SIZE() {
+        assertEquals(3 * 8, CvType.ELEM_SIZE(CvType.CV_64FC3));
+    }
+
+    public void testTypeToString() {
+        assertEquals("CV_32FC1", CvType.typeToString(CvType.CV_32F));
+        assertEquals("CV_32FC3", CvType.typeToString(CvType.CV_32FC3));
+        assertEquals("CV_32FC(128)", CvType.typeToString(CvType.CV_32FC(128)));
+    }
+
+}

modules/core/misc/java/test/DMatchTest.java

@@ -0,0 +1,44 @@
+package org.opencv.test.core;
+
+import org.opencv.core.DMatch;
+
+import junit.framework.TestCase;
+
+public class DMatchTest extends TestCase {
+    public void testDMatch() {
+        new DMatch();
+    }
+
+    public void testDMatchIntIntFloat() {
+        DMatch dm1 = new DMatch(1, 4, 4.0f);
+
+        assertEquals(1, dm1.queryIdx);
+        assertEquals(4, dm1.trainIdx);
+        assertEquals(4.0f, dm1.distance);
+    }
+
+    public void testDMatchIntIntIntFloat() {
+        DMatch dm2 = new DMatch(2, 6, -1, 8.0f);
+
+        assertEquals(2, dm2.queryIdx);
+        assertEquals(6, dm2.trainIdx);
+        assertEquals(-1, dm2.imgIdx);
+        assertEquals(8.0f, dm2.distance);
+    }
+
+    public void testLessThan() {
+        DMatch dm1 = new DMatch(1, 4, 4.0f);
+        DMatch dm2 = new DMatch(2, 6, -1, 8.0f);
+        assertTrue(dm1.lessThan(dm2));
+    }
+
+    public void testToString() {
+        DMatch dm2 = new DMatch(2, 6, -1, 8.0f);
+
+        String actual = dm2.toString();
+
+        String expected = "DMatch [queryIdx=2, trainIdx=6, imgIdx=-1, distance=8.0]";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/KeyPointTest.java

@@ -0,0 +1,71 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.KeyPoint;
+import org.opencv.test.OpenCVTestCase;
+
+public class KeyPointTest extends OpenCVTestCase {
+
+    private float angle;
+    private int classId;
+    private KeyPoint keyPoint;
+    private int octave;
+    private float response;
+    private float size;
+    private float x;
+    private float y;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        keyPoint = null;
+        x = 1.0f;
+        y = 2.0f;
+        size = 3.0f;
+        angle = 30.0f;
+        response = 2.0f;
+        octave = 1;
+        classId = 1;
+    }
+
+    public void testKeyPoint() {
+        keyPoint = new KeyPoint();
+        assertPointEquals(new Point(0, 0), keyPoint.pt, EPS);
+    }
+
+    public void testKeyPointFloatFloatFloat() {
+        keyPoint = new KeyPoint(x, y, size);
+        assertPointEquals(new Point(1, 2), keyPoint.pt, EPS);
+    }
+
+    public void testKeyPointFloatFloatFloatFloat() {
+        keyPoint = new KeyPoint(x, y, size, 10.0f);
+        assertEquals(10.0f, keyPoint.angle);
+    }
+
+    public void testKeyPointFloatFloatFloatFloatFloat() {
+        keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f);
+        assertEquals(1.0f, keyPoint.response);
+    }
+
+    public void testKeyPointFloatFloatFloatFloatFloatInt() {
+        keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f, 1);
+        assertEquals(1, keyPoint.octave);
+    }
+
+    public void testKeyPointFloatFloatFloatFloatFloatIntInt() {
+        keyPoint = new KeyPoint(x, y, size, 1.0f, 1.0f, 1, 1);
+        assertEquals(1, keyPoint.class_id);
+    }
+
+    public void testToString() {
+        keyPoint = new KeyPoint(x, y, size, angle, response, octave, classId);
+
+        String actual = keyPoint.toString();
+
+        String expected = "KeyPoint [pt={1.0, 2.0}, size=3.0, angle=30.0, response=2.0, octave=1, class_id=1]";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/Point3Test.java

@@ -0,0 +1,107 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Point3;
+import org.opencv.test.OpenCVTestCase;
+
+public class Point3Test extends OpenCVTestCase {
+
+    private Point3 p1;
+    private Point3 p2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        p1 = new Point3(2, 2, 2);
+        p2 = new Point3(1, 1, 1);
+    }
+
+    public void testClone() {
+        Point3 truth = new Point3(1, 1, 1);
+        p1 = truth.clone();
+        assertEquals(truth, p1);
+    }
+
+    public void testCross() {
+        Point3 dstPoint = p1.cross(p2);
+        Point3 truth = new Point3(0, 0, 0);
+        assertEquals(truth, dstPoint);
+    }
+
+    public void testDot() {
+        double result = p1.dot(p2);
+        assertEquals(6.0, result);
+    }
+
+    public void testEqualsObject() {
+        boolean flag = p1.equals(p1);
+        assertTrue(flag);
+
+        flag = p1.equals(p2);
+        assertFalse(flag);
+    }
+
+    public void testHashCode() {
+        assertEquals(p1.hashCode(), p1.hashCode());
+    }
+
+    public void testPoint3() {
+        p1 = new Point3();
+
+        assertNotNull(p1);
+        assertTrue(0 == p1.x);
+        assertTrue(0 == p1.y);
+        assertTrue(0 == p1.z);
+    }
+
+    public void testPoint3DoubleArray() {
+        double[] vals = { 1, 2, 3 };
+        p1 = new Point3(vals);
+
+        assertTrue(1 == p1.x);
+        assertTrue(2 == p1.y);
+        assertTrue(3 == p1.z);
+    }
+
+    public void testPoint3DoubleDoubleDouble() {
+        p1 = new Point3(1, 2, 3);
+
+        assertEquals(1., p1.x);
+        assertEquals(2., p1.y);
+        assertEquals(3., p1.z);
+    }
+
+    public void testPoint3Point() {
+        Point p = new Point(2, 3);
+        p1 = new Point3(p);
+
+        assertEquals(2., p1.x);
+        assertEquals(3., p1.y);
+        assertEquals(0., p1.z);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        p1.set(vals1);
+
+        assertEquals(0., p1.x);
+        assertEquals(0., p1.y);
+        assertEquals(0., p1.z);
+
+        double[] vals2 = { 3, 6, 10 };
+        p1.set(vals2);
+
+        assertEquals(3., p1.x);
+        assertEquals(6., p1.y);
+        assertEquals(10., p1.z);
+    }
+
+    public void testToString() {
+        String actual = p1.toString();
+        String expected = "{2.0, 2.0, 2.0}";
+        assertEquals(expected, actual);
+    }
+
+
+}

modules/core/misc/java/test/PointTest.java

@@ -0,0 +1,93 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.test.OpenCVTestCase;
+
+public class PointTest extends OpenCVTestCase {
+
+    private Point p1;
+    private Point p2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        p1 = new Point(2, 2);
+        p2 = new Point(1, 1);
+    }
+
+    public void testClone() {
+        Point truth = new Point(1, 1);
+        Point dstPoint = truth.clone();
+        assertEquals(truth, dstPoint);
+    }
+
+    public void testDot() {
+        double result = p1.dot(p2);
+        assertEquals(4.0, result);
+    }
+
+    public void testEqualsObject() {
+        boolean flag = p1.equals(p1);
+        assertTrue(flag);
+
+        flag = p1.equals(p2);
+        assertFalse(flag);
+    }
+
+    public void testHashCode() {
+        assertEquals(p1.hashCode(), p1.hashCode());
+    }
+
+    public void testInside() {
+        Rect rect = new Rect(0, 0, 5, 3);
+        assertTrue(p1.inside(rect));
+
+        Point p2 = new Point(3, 3);
+        assertFalse(p2.inside(rect));
+    }
+
+    public void testPoint() {
+        Point p = new Point();
+
+        assertNotNull(p);
+        assertEquals(0.0, p.x);
+        assertEquals(0.0, p.y);
+    }
+
+    public void testPointDoubleArray() {
+        double[] vals = { 2, 4 };
+        Point p = new Point(vals);
+
+        assertEquals(2.0, p.x);
+        assertEquals(4.0, p.y);
+    }
+
+    public void testPointDoubleDouble() {
+        p1 = new Point(7, 5);
+
+        assertNotNull(p1);
+        assertEquals(7.0, p1.x);
+        assertEquals(5.0, p1.y);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        p1.set(vals1);
+        assertEquals(0.0, p1.x);
+        assertEquals(0.0, p1.y);
+
+        double[] vals2 = { 6, 10 };
+        p2.set(vals2);
+        assertEquals(6.0, p2.x);
+        assertEquals(10.0, p2.y);
+    }
+
+    public void testToString() {
+        String actual = p1.toString();
+        String expected = "{2.0, 2.0}";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/RangeTest.java

@@ -0,0 +1,113 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Range;
+import org.opencv.test.OpenCVTestCase;
+
+public class RangeTest extends OpenCVTestCase {
+
+    Range r1;
+    Range r2;
+    Range range;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        range = new Range();
+        r1 = new Range(1, 11);
+        r2 = new Range(1, 1);
+    }
+
+    public void testAll() {
+        range = Range.all();
+        assertEquals(Integer.MIN_VALUE, range.start);
+        assertEquals(Integer.MAX_VALUE, range.end);
+    }
+
+    public void testClone() {
+        Range dstRange = new Range();
+        dstRange = r1.clone();
+        assertEquals(r1, dstRange);
+    }
+
+    public void testEmpty() {
+        boolean flag;
+
+        flag = r1.empty();
+        assertFalse(flag);
+
+        flag = r2.empty();
+        assertTrue(flag);
+    }
+
+    public void testEqualsObject() {
+        assertFalse(r2.equals(r1));
+
+        range = r1.clone();
+        assertTrue(r1.equals(range));
+    }
+
+    public void testHashCode() {
+        assertEquals(r1.hashCode(), r1.hashCode());
+    }
+
+    public void testIntersection() {
+        range = r1.intersection(r2);
+        assertEquals(r2, range);
+    }
+
+    public void testRange() {
+        range = new Range();
+
+        assertNotNull(range);
+        assertEquals(0, range.start);
+        assertEquals(0, range.end);
+    }
+
+    public void testRangeDoubleArray() {
+        double[] vals = { 2, 4 };
+        Range r = new Range(vals);
+
+        assertTrue(2 == r.start);
+        assertTrue(4 == r.end);
+    }
+
+    public void testRangeIntInt() {
+        r1 = new Range(12, 13);
+
+        assertNotNull(r1);
+        assertEquals(12, r1.start);
+        assertEquals(13, r1.end);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        r1.set(vals1);
+        assertEquals(0, r1.start);
+        assertEquals(0, r1.end);
+
+        double[] vals2 = { 6, 10 };
+        r2.set(vals2);
+        assertEquals(6, r2.start);
+        assertEquals(10, r2.end);
+    }
+
+    public void testShift() {
+        int delta = 1;
+        range = range.shift(delta);
+        assertEquals(r2, range);
+    }
+
+    public void testSize() {
+        assertEquals(10, r1.size());
+
+        assertEquals(0, r2.size());
+    }
+
+    public void testToString() {
+        String actual = r1.toString();
+        String expected = "[1, 11)";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/RectTest.java

@@ -0,0 +1,163 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+public class RectTest extends OpenCVTestCase {
+
+    private Rect r;
+    private Rect rect;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        r = new Rect();
+        rect = new Rect(0, 0, 10, 10);
+    }
+
+    public void testArea() {
+        double area;
+        area = rect.area();
+        assertEquals(100.0, area);
+    }
+
+    public void testBr() {
+        Point p_br = new Point();
+        p_br = rect.br();
+        Point truth = new Point(10, 10);
+        assertEquals(truth, p_br);
+    }
+
+    public void testClone() {
+        r = rect.clone();
+        assertEquals(rect, r);
+    }
+
+    public void testContains() {
+        Rect rect = new Rect(0, 0, 10, 10);
+
+        Point p_inner = new Point(5, 5);
+        Point p_outer = new Point(5, 55);
+        Point p_bl = new Point(0, 0);
+        Point p_br = new Point(10, 0);
+        Point p_tl = new Point(0, 10);
+        Point p_tr = new Point(10, 10);
+
+        assertTrue(rect.contains(p_inner));
+        assertTrue(rect.contains(p_bl));
+
+        assertFalse(rect.contains(p_outer));
+        assertFalse(rect.contains(p_br));
+        assertFalse(rect.contains(p_tl));
+        assertFalse(rect.contains(p_tr));
+    }
+
+    public void testEqualsObject() {
+        boolean flag;
+        flag = rect.equals(r);
+        assertFalse(flag);
+
+        r = rect.clone();
+        flag = rect.equals(r);
+        assertTrue(flag);
+    }
+
+    public void testHashCode() {
+        assertEquals(rect.hashCode(), rect.hashCode());
+    }
+
+    public void testRect() {
+        r = new Rect();
+
+        assertEquals(0, r.x);
+        assertEquals(0, r.y);
+        assertEquals(0, r.width);
+        assertEquals(0, r.height);
+    }
+
+    public void testRectDoubleArray() {
+        double[] vals = { 1, 3, 5, 2 };
+        r = new Rect(vals);
+
+        assertEquals(1, r.x);
+        assertEquals(3, r.y);
+        assertEquals(5, r.width);
+        assertEquals(2, r.height);
+    }
+
+    public void testRectIntIntIntInt() {
+        r = new Rect(1, 3, 5, 2);
+
+        assertNotNull(rect);
+        assertEquals(0, rect.x);
+        assertEquals(0, rect.y);
+        assertEquals(10, rect.width);
+        assertEquals(10, rect.height);
+    }
+
+    public void testRectPointPoint() {
+        Point p1 = new Point(4, 4);
+        Point p2 = new Point(2, 3);
+
+        r = new Rect(p1, p2);
+        assertNotNull(r);
+        assertEquals(2, r.x);
+        assertEquals(3, r.y);
+        assertEquals(2, r.width);
+        assertEquals(1, r.height);
+    }
+
+    public void testRectPointSize() {
+        Point p1 = new Point(4, 4);
+        Size sz = new Size(3, 1);
+        r = new Rect(p1, sz);
+
+        assertEquals(4, r.x);
+        assertEquals(4, r.y);
+        assertEquals(3, r.width);
+        assertEquals(1, r.height);
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        Rect r1 = new Rect(vals1);
+
+        assertEquals(0, r1.x);
+        assertEquals(0, r1.y);
+        assertEquals(0, r1.width);
+        assertEquals(0, r1.height);
+
+        double[] vals2 = { 2, 2, 10, 5 };
+        r = new Rect(vals2);
+
+        assertEquals(2, r.x);
+        assertEquals(2, r.y);
+        assertEquals(10, r.width);
+        assertEquals(5, r.height);
+    }
+
+    public void testSize() {
+        Size s1 = new Size(0, 0);
+        assertEquals(s1, r.size());
+
+        Size s2 = new Size(10, 10);
+        assertEquals(s2, rect.size());
+    }
+
+    public void testTl() {
+        Point p_tl = new Point();
+        p_tl = rect.tl();
+        Point truth = new Point(0, 0);
+        assertEquals(truth, p_tl);
+    }
+
+    public void testToString() {
+        String actual = rect.toString();
+        String expected = "{0, 0, 10x10}";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/RotatedRectTest.java

@@ -0,0 +1,191 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Rect;
+import org.opencv.core.RotatedRect;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+public class RotatedRectTest extends OpenCVTestCase {
+
+    private double angle;
+    private Point center;
+    private Size size;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        center = new Point(matSize / 2, matSize / 2);
+        size = new Size(matSize / 4, matSize / 2);
+        angle = 40;
+    }
+
+    public void testBoundingRect() {
+        size = new Size(matSize / 2, matSize / 2);
+        assertEquals(size.height, size.width);
+        double length = size.height;
+
+        angle = 45;
+        RotatedRect rr = new RotatedRect(center, size, angle);
+
+        Rect r = rr.boundingRect();
+        double halfDiagonal = length * Math.sqrt(2) / 2;
+
+        assertTrue((r.x == Math.floor(center.x - halfDiagonal)) && (r.y == Math.floor(center.y - halfDiagonal)));
+
+        assertTrue((r.br().x >= Math.ceil(center.x + halfDiagonal)) && (r.br().y >= Math.ceil(center.y + halfDiagonal)));
+
+        assertTrue((r.br().x - Math.ceil(center.x + halfDiagonal)) <= 1 && (r.br().y - Math.ceil(center.y + halfDiagonal)) <= 1);
+    }
+
+    public void testClone() {
+        RotatedRect rrect = new RotatedRect(center, size, angle);
+        RotatedRect clone = rrect.clone();
+
+        assertTrue(clone != null);
+        assertTrue(rrect.center.equals(clone.center));
+        assertTrue(rrect.size.equals(clone.size));
+        assertTrue(rrect.angle == clone.angle);
+    }
+
+    public void testEqualsObject() {
+        Point center2 = new Point(matSize / 3, matSize / 1.5);
+        Size size2 = new Size(matSize / 2, matSize / 4);
+        double angle2 = 0;
+
+        RotatedRect rrect1 = new RotatedRect(center, size, angle);
+        RotatedRect rrect2 = new RotatedRect(center2, size2, angle2);
+        RotatedRect rrect3 = rrect1;
+        RotatedRect clone1 = rrect1.clone();
+        RotatedRect clone2 = rrect2.clone();
+
+        assertTrue(rrect1.equals(rrect3));
+        assertTrue(!rrect1.equals(rrect2));
+
+        assertTrue(rrect2.equals(clone2));
+        clone2.angle = 10;
+        assertTrue(!rrect2.equals(clone2));
+
+        assertTrue(rrect1.equals(clone1));
+
+        clone1.center.x += 1;
+        assertTrue(!rrect1.equals(clone1));
+
+        clone1.center.x -= 1;
+        assertTrue(rrect1.equals(clone1));
+
+        clone1.size.width += 1;
+        assertTrue(!rrect1.equals(clone1));
+
+        assertTrue(!rrect1.equals(size));
+    }
+
+    public void testHashCode() {
+        RotatedRect rr = new RotatedRect(center, size, angle);
+        assertEquals(rr.hashCode(), rr.hashCode());
+    }
+
+    public void testPoints() {
+        RotatedRect rrect = new RotatedRect(center, size, angle);
+
+        Point p[] = new Point[4];
+        rrect.points(p);
+
+        boolean is_p0_irrational = (100 * p[0].x != (int) (100 * p[0].x)) && (100 * p[0].y != (int) (100 * p[0].y));
+        boolean is_p1_irrational = (100 * p[1].x != (int) (100 * p[1].x)) && (100 * p[1].y != (int) (100 * p[1].y));
+        boolean is_p2_irrational = (100 * p[2].x != (int) (100 * p[2].x)) && (100 * p[2].y != (int) (100 * p[2].y));
+        boolean is_p3_irrational = (100 * p[3].x != (int) (100 * p[3].x)) && (100 * p[3].y != (int) (100 * p[3].y));
+
+        assertTrue(is_p0_irrational && is_p1_irrational && is_p2_irrational && is_p3_irrational);
+
+        assertTrue("Symmetric points 0 and 2",
+                Math.abs((p[0].x + p[2].x) / 2 - center.x) + Math.abs((p[0].y + p[2].y) / 2 - center.y) < EPS);
+
+        assertTrue("Symmetric points 1 and 3",
+                Math.abs((p[1].x + p[3].x) / 2 - center.x) + Math.abs((p[1].y + p[3].y) / 2 - center.y) < EPS);
+
+        assertTrue("Orthogonal vectors 01 and 12",
+                Math.abs((p[1].x - p[0].x) * (p[2].x - p[1].x) +
+                        (p[1].y - p[0].y) * (p[2].y - p[1].y)) < EPS);
+
+        assertTrue("Orthogonal vectors 12 and 23",
+                Math.abs((p[2].x - p[1].x) * (p[3].x - p[2].x) +
+                        (p[2].y - p[1].y) * (p[3].y - p[2].y)) < EPS);
+
+        assertTrue("Orthogonal vectors 23 and 30",
+                Math.abs((p[3].x - p[2].x) * (p[0].x - p[3].x) +
+                        (p[3].y - p[2].y) * (p[0].y - p[3].y)) < EPS);
+
+        assertTrue("Orthogonal vectors 30 and 01",
+                Math.abs((p[0].x - p[3].x) * (p[1].x - p[0].x) +
+                        (p[0].y - p[3].y) * (p[1].y - p[0].y)) < EPS);
+
+        assertTrue("Length of the vector 01",
+                Math.abs((p[1].x - p[0].x) * (p[1].x - p[0].x) +
+                        (p[1].y - p[0].y) * (p[1].y - p[0].y) - size.height * size.height) < EPS);
+
+        assertTrue("Length of the vector 21",
+                Math.abs((p[1].x - p[2].x) * (p[1].x - p[2].x) +
+                        (p[1].y - p[2].y) * (p[1].y - p[2].y) - size.width * size.width) < EPS);
+
+        assertTrue("Angle of the vector 21 with the axes", Math.abs((p[2].x - p[1].x) / size.width - Math.cos(angle * Math.PI / 180)) < EPS);
+    }
+
+    public void testRotatedRect() {
+        RotatedRect rr = new RotatedRect();
+
+        assertTrue(rr != null);
+        assertTrue(rr.center != null);
+        assertTrue(rr.size != null);
+        assertTrue(rr.angle == 0.0);
+    }
+
+    public void testRotatedRectDoubleArray() {
+        double[] vals = { 1.5, 2.6, 3.7, 4.2, 5.1 };
+        RotatedRect rr = new RotatedRect(vals);
+
+        assertNotNull(rr);
+        assertEquals(1.5, rr.center.x);
+        assertEquals(2.6, rr.center.y);
+        assertEquals(3.7, rr.size.width);
+        assertEquals(4.2, rr.size.height);
+        assertEquals(5.1, rr.angle);
+    }
+
+    public void testRotatedRectPointSizeDouble() {
+        RotatedRect rr = new RotatedRect(center, size, 40);
+
+        assertTrue(rr != null);
+        assertTrue(rr.center != null);
+        assertTrue(rr.size != null);
+        assertTrue(rr.angle == 40.0);
+    }
+
+    public void testSet() {
+        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 expected = "{ {1.0, 2.0} 10x12 * 4.5 }";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/ScalarTest.java

@@ -0,0 +1,110 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Scalar;
+import org.opencv.test.OpenCVTestCase;
+
+public class ScalarTest extends OpenCVTestCase {
+
+    private Scalar dstScalar;
+    private Scalar s1;
+    private Scalar s2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        s1 = new Scalar(1.0);
+        s2 = Scalar.all(1.0);
+        dstScalar = null;
+    }
+
+    public void testAll() {
+        dstScalar = Scalar.all(2.0);
+        Scalar truth = new Scalar(2.0, 2.0, 2.0, 2.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testClone() {
+        dstScalar = s2.clone();
+        assertEquals(s2, dstScalar);
+    }
+
+    public void testConj() {
+        dstScalar = s2.conj();
+        Scalar truth = new Scalar(1, -1, -1, -1);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testEqualsObject() {
+        dstScalar = s2.clone();
+        assertTrue(s2.equals(dstScalar));
+
+        assertFalse(s2.equals(s1));
+    }
+
+    public void testHashCode() {
+        assertEquals(s2.hashCode(), s2.hashCode());
+    }
+
+    public void testIsReal() {
+        assertTrue(s1.isReal());
+
+        assertFalse(s2.isReal());
+    }
+
+    public void testMulScalar() {
+        dstScalar = s2.mul(s1);
+        assertEquals(s1, dstScalar);
+    }
+
+    public void testMulScalarDouble() {
+        double multiplier = 2.0;
+        dstScalar = s2.mul(s1, multiplier);
+        Scalar truth = new Scalar(2);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDouble() {
+        Scalar truth = new Scalar(1);
+        assertEquals(truth, s1);
+    }
+
+    public void testScalarDoubleArray() {
+        double[] vals = { 2.0, 4.0, 5.0, 3.0 };
+        dstScalar = new Scalar(vals);
+
+        Scalar truth = new Scalar(2.0, 4.0, 5.0, 3.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDoubleDouble() {
+        dstScalar = new Scalar(2, 5);
+        Scalar truth = new Scalar(2.0, 5.0, 0.0, 0.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDoubleDoubleDouble() {
+        dstScalar = new Scalar(2.0, 5.0, 5.0);
+        Scalar truth = new Scalar(2.0, 5.0, 5.0, 0.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testScalarDoubleDoubleDoubleDouble() {
+        dstScalar = new Scalar(2.0, 5.0, 5.0, 9.0);
+        Scalar truth = new Scalar(2.0, 5.0, 5.0, 9.0);
+        assertEquals(truth, dstScalar);
+    }
+
+    public void testSet() {
+        double[] vals = { 1.0, 1.0, 1.0, 1.0 };
+        s1.set(vals);
+        assertEquals(s2, s1);
+    }
+
+    public void testToString() {
+        String actual = s2.toString();
+        String expected = "[1.0, 1.0, 1.0, 1.0]";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/SizeTest.java

@@ -0,0 +1,93 @@
+package org.opencv.test.core;
+
+import org.opencv.core.Point;
+import org.opencv.core.Size;
+import org.opencv.test.OpenCVTestCase;
+
+public class SizeTest extends OpenCVTestCase {
+
+    Size dstSize;
+    Size sz1;
+    Size sz2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        sz1 = new Size(10.0, 10.0);
+        sz2 = new Size(-1, -1);
+        dstSize = null;
+    }
+
+    public void testArea() {
+        double area = sz1.area();
+        assertEquals(100.0, area);
+    }
+
+    public void testClone() {
+        dstSize = sz1.clone();
+        assertEquals(sz1, dstSize);
+    }
+
+    public void testEqualsObject() {
+        assertFalse(sz1.equals(sz2));
+
+        sz2 = sz1.clone();
+        assertTrue(sz1.equals(sz2));
+    }
+
+    public void testHashCode() {
+        assertEquals(sz1.hashCode(), sz1.hashCode());
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        sz2.set(vals1);
+        assertEquals(0., sz2.width);
+        assertEquals(0., sz2.height);
+
+        double[] vals2 = { 9, 12 };
+        sz1.set(vals2);
+        assertEquals(9., sz1.width);
+        assertEquals(12., sz1.height);
+    }
+
+    public void testSize() {
+        dstSize = new Size();
+
+        assertNotNull(dstSize);
+        assertEquals(0., dstSize.width);
+        assertEquals(0., dstSize.height);
+    }
+
+    public void testSizeDoubleArray() {
+        double[] vals = { 10, 20 };
+        sz2 = new Size(vals);
+
+        assertEquals(10., sz2.width);
+        assertEquals(20., sz2.height);
+    }
+
+    public void testSizeDoubleDouble() {
+        assertNotNull(sz1);
+
+        assertEquals(10.0, sz1.width);
+        assertEquals(10.0, sz1.height);
+    }
+
+    public void testSizePoint() {
+        Point p = new Point(2, 4);
+        sz1 = new Size(p);
+
+        assertNotNull(sz1);
+        assertEquals(2.0, sz1.width);
+        assertEquals(4.0, sz1.height);
+    }
+
+    public void testToString() {
+        String actual = sz1.toString();
+        String expected = "10x10";
+        assertEquals(expected, actual);
+    }
+
+}

modules/core/misc/java/test/TermCriteriaTest.java

@@ -0,0 +1,86 @@
+package org.opencv.test.core;
+
+import org.opencv.core.TermCriteria;
+import org.opencv.test.OpenCVTestCase;
+
+public class TermCriteriaTest extends OpenCVTestCase {
+
+    private TermCriteria tc1;
+    private TermCriteria tc2;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        tc1 = new TermCriteria();
+        tc2 = new TermCriteria(2, 4, EPS);
+    }
+
+    public void testClone() {
+        tc1 = tc2.clone();
+        assertEquals(tc2, tc1);
+    }
+
+    public void testEqualsObject() {
+        assertFalse(tc2.equals(tc1));
+
+        tc1 = tc2.clone();
+        assertTrue(tc2.equals(tc1));
+    }
+
+    public void testHashCode() {
+        assertEquals(tc2.hashCode(), tc2.hashCode());
+    }
+
+    public void testSet() {
+        double[] vals1 = {};
+        tc1.set(vals1);
+
+        assertEquals(0, tc1.type);
+        assertEquals(0, tc1.maxCount);
+        assertEquals(0.0, tc1.epsilon);
+
+        double[] vals2 = { 9, 8, 0.002 };
+        tc2.set(vals2);
+
+        assertEquals(9, tc2.type);
+        assertEquals(8, tc2.maxCount);
+        assertEquals(0.002, tc2.epsilon);
+    }
+
+    public void testTermCriteria() {
+        tc1 = new TermCriteria();
+
+        assertNotNull(tc1);
+        assertEquals(0, tc1.type);
+        assertEquals(0, tc1.maxCount);
+        assertEquals(0.0, tc1.epsilon);
+    }
+
+    public void testTermCriteriaDoubleArray() {
+        double[] vals = { 3, 2, 0.007 };
+        tc1 = new TermCriteria(vals);
+
+        assertEquals(3, tc1.type);
+        assertEquals(2, tc1.maxCount);
+        assertEquals(0.007, tc1.epsilon);
+    }
+
+    public void testTermCriteriaIntIntDouble() {
+        tc1 = new TermCriteria(2, 4, EPS);
+
+        assertNotNull(tc2);
+        assertEquals(2, tc2.type);
+        assertEquals(4, tc2.maxCount);
+        assertEquals(EPS, tc2.epsilon);
+    }
+
+    public void testToString() {
+        String actual = tc2.toString();
+        double eps = EPS;
+        String expected = "{ type: 2, maxCount: 4, epsilon: " + eps + "}";
+
+        assertEquals(expected, actual);
+    }
+
+}