1package org.opencv.test.core;
2
3import org.opencv.core.Point;
4import org.opencv.core.Rect;
5import org.opencv.core.RotatedRect;
6import org.opencv.core.Size;
7import org.opencv.test.OpenCVTestCase;
8
9public class RotatedRectTest extends OpenCVTestCase {
10
11    private double angle;
12    private Point center;
13    private Size size;
14
15    @Override
16    protected void setUp() throws Exception {
17        super.setUp();
18
19        center = new Point(matSize / 2, matSize / 2);
20        size = new Size(matSize / 4, matSize / 2);
21        angle = 40;
22    }
23
24    public void testBoundingRect() {
25        size = new Size(matSize / 2, matSize / 2);
26        assertEquals(size.height, size.width);
27        double length = size.height;
28
29        angle = 45;
30        RotatedRect rr = new RotatedRect(center, size, angle);
31
32        Rect r = rr.boundingRect();
33        double halfDiagonal = length * Math.sqrt(2) / 2;
34
35        assertTrue((r.x == Math.floor(center.x - halfDiagonal)) && (r.y == Math.floor(center.y - halfDiagonal)));
36
37        assertTrue((r.br().x >= Math.ceil(center.x + halfDiagonal)) && (r.br().y >= Math.ceil(center.y + halfDiagonal)));
38
39        assertTrue((r.br().x - Math.ceil(center.x + halfDiagonal)) <= 1 && (r.br().y - Math.ceil(center.y + halfDiagonal)) <= 1);
40    }
41
42    public void testClone() {
43        RotatedRect rrect = new RotatedRect(center, size, angle);
44        RotatedRect clone = rrect.clone();
45
46        assertTrue(clone != null);
47        assertTrue(rrect.center.equals(clone.center));
48        assertTrue(rrect.size.equals(clone.size));
49        assertTrue(rrect.angle == clone.angle);
50    }
51
52    public void testEqualsObject() {
53        Point center2 = new Point(matSize / 3, matSize / 1.5);
54        Size size2 = new Size(matSize / 2, matSize / 4);
55        double angle2 = 0;
56
57        RotatedRect rrect1 = new RotatedRect(center, size, angle);
58        RotatedRect rrect2 = new RotatedRect(center2, size2, angle2);
59        RotatedRect rrect3 = rrect1;
60        RotatedRect clone1 = rrect1.clone();
61        RotatedRect clone2 = rrect2.clone();
62
63        assertTrue(rrect1.equals(rrect3));
64        assertTrue(!rrect1.equals(rrect2));
65
66        assertTrue(rrect2.equals(clone2));
67        clone2.angle = 10;
68        assertTrue(!rrect2.equals(clone2));
69
70        assertTrue(rrect1.equals(clone1));
71
72        clone1.center.x += 1;
73        assertTrue(!rrect1.equals(clone1));
74
75        clone1.center.x -= 1;
76        assertTrue(rrect1.equals(clone1));
77
78        clone1.size.width += 1;
79        assertTrue(!rrect1.equals(clone1));
80
81        assertTrue(!rrect1.equals(size));
82    }
83
84    public void testHashCode() {
85        RotatedRect rr = new RotatedRect(center, size, angle);
86        assertEquals(rr.hashCode(), rr.hashCode());
87    }
88
89    public void testPoints() {
90        RotatedRect rrect = new RotatedRect(center, size, angle);
91
92        Point p[] = new Point[4];
93        rrect.points(p);
94
95        boolean is_p0_irrational = (100 * p[0].x != (int) (100 * p[0].x)) && (100 * p[0].y != (int) (100 * p[0].y));
96        boolean is_p1_irrational = (100 * p[1].x != (int) (100 * p[1].x)) && (100 * p[1].y != (int) (100 * p[1].y));
97        boolean is_p2_irrational = (100 * p[2].x != (int) (100 * p[2].x)) && (100 * p[2].y != (int) (100 * p[2].y));
98        boolean is_p3_irrational = (100 * p[3].x != (int) (100 * p[3].x)) && (100 * p[3].y != (int) (100 * p[3].y));
99
100        assertTrue(is_p0_irrational && is_p1_irrational && is_p2_irrational && is_p3_irrational);
101
102        assertTrue("Symmetric points 0 and 2",
103                Math.abs((p[0].x + p[2].x) / 2 - center.x) + Math.abs((p[0].y + p[2].y) / 2 - center.y) < EPS);
104
105        assertTrue("Symmetric points 1 and 3",
106                Math.abs((p[1].x + p[3].x) / 2 - center.x) + Math.abs((p[1].y + p[3].y) / 2 - center.y) < EPS);
107
108        assertTrue("Orthogonal vectors 01 and 12",
109                Math.abs((p[1].x - p[0].x) * (p[2].x - p[1].x) +
110                        (p[1].y - p[0].y) * (p[2].y - p[1].y)) < EPS);
111
112        assertTrue("Orthogonal vectors 12 and 23",
113                Math.abs((p[2].x - p[1].x) * (p[3].x - p[2].x) +
114                        (p[2].y - p[1].y) * (p[3].y - p[2].y)) < EPS);
115
116        assertTrue("Orthogonal vectors 23 and 30",
117                Math.abs((p[3].x - p[2].x) * (p[0].x - p[3].x) +
118                        (p[3].y - p[2].y) * (p[0].y - p[3].y)) < EPS);
119
120        assertTrue("Orthogonal vectors 30 and 01",
121                Math.abs((p[0].x - p[3].x) * (p[1].x - p[0].x) +
122                        (p[0].y - p[3].y) * (p[1].y - p[0].y)) < EPS);
123
124        assertTrue("Length of the vector 01",
125                Math.abs((p[1].x - p[0].x) * (p[1].x - p[0].x) +
126                        (p[1].y - p[0].y) * (p[1].y - p[0].y) - size.height * size.height) < EPS);
127
128        assertTrue("Length of the vector 21",
129                Math.abs((p[1].x - p[2].x) * (p[1].x - p[2].x) +
130                        (p[1].y - p[2].y) * (p[1].y - p[2].y) - size.width * size.width) < EPS);
131
132        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);
133    }
134
135    public void testRotatedRect() {
136        RotatedRect rr = new RotatedRect();
137
138        assertTrue(rr != null);
139        assertTrue(rr.center != null);
140        assertTrue(rr.size != null);
141        assertTrue(rr.angle == 0.0);
142    }
143
144    public void testRotatedRectDoubleArray() {
145        double[] vals = { 1.5, 2.6, 3.7, 4.2, 5.1 };
146        RotatedRect rr = new RotatedRect(vals);
147
148        assertNotNull(rr);
149        assertEquals(1.5, rr.center.x);
150        assertEquals(2.6, rr.center.y);
151        assertEquals(3.7, rr.size.width);
152        assertEquals(4.2, rr.size.height);
153        assertEquals(5.1, rr.angle);
154    }
155
156    public void testRotatedRectPointSizeDouble() {
157        RotatedRect rr = new RotatedRect(center, size, 40);
158
159        assertTrue(rr != null);
160        assertTrue(rr.center != null);
161        assertTrue(rr.size != null);
162        assertTrue(rr.angle == 40.0);
163    }
164
165    public void testSet() {
166        double[] vals1 = {};
167        RotatedRect r1 = new RotatedRect(center, size, 40);
168
169        r1.set(vals1);
170
171        assertEquals(0., r1.angle);
172        assertPointEquals(new Point(0, 0), r1.center, EPS);
173        assertSizeEquals(new Size(0, 0), r1.size, EPS);
174
175        double[] vals2 = { 1, 2, 3, 4, 5 };
176        RotatedRect r2 = new RotatedRect(center, size, 40);
177
178        r2.set(vals2);
179
180        assertEquals(5., r2.angle);
181        assertPointEquals(new Point(1, 2), r2.center, EPS);
182        assertSizeEquals(new Size(3, 4), r2.size, EPS);
183    }
184
185    public void testToString() {
186        String actual = new RotatedRect(new Point(1, 2), new Size(10, 12), 4.5).toString();
187        String expected = "{ {1.0, 2.0} 10x12 * 4.5 }";
188        assertEquals(expected, actual);
189    }
190
191}
192