1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
//
// RotatedRectTest.swift
//
// Created by Giles Payne on 2020/01/31.
//
import XCTest
import OpenCV
class RotatedRectTest: OpenCVTestCase {
let angle: Double = 40
let center = Point2f(x: Float(OpenCVTestCase.matSize / 2), y: Float(OpenCVTestCase.matSize / 2))
let size = Size2f(width: Float(OpenCVTestCase.matSize / 4), height: Float(OpenCVTestCase.matSize / 2))
func testBoundingRect() {
let size = Size2f(width: Float(OpenCVTestCase.matSize / 2), height: Float(OpenCVTestCase.matSize / 2));
XCTAssertEqual(size.height, size.width);
let length = size.height;
let angle: Double = 45
let rr = RotatedRect(center: center, size: size, angle: angle)
let r = rr.boundingRect()
let halfDiagonal = length * sqrt(2) / 2
XCTAssert(Float(r.x) == floor(center.x - halfDiagonal) && Float(r.y) == floor(center.y - halfDiagonal))
XCTAssert((r.br().x >= ceil(center.x + halfDiagonal)) && (r.br().y >= ceil(center.y + halfDiagonal)))
XCTAssert((r.br().x - ceil(center.x + halfDiagonal)) <= 1 && (r.br().y - ceil(center.y + halfDiagonal)) <= 1)
}
func testClone() {
let rrect = RotatedRect(center: center, size: size, angle: angle)
let clone = rrect.clone();
XCTAssertNotNil(clone)
XCTAssert(rrect.center == clone.center)
XCTAssert(rrect.size == clone.size)
XCTAssert(rrect.angle == clone.angle)
}
func testEqualsObject() {
let center2 = Point2f(x: Float(OpenCVTestCase.matSize / 3), y: Float(OpenCVTestCase.matSize) / 1.5)
let size2 = Size2f(width: Float(OpenCVTestCase.matSize / 2), height: Float(OpenCVTestCase.matSize / 4))
let angle2:Double = 0
let rrect1 = RotatedRect(center: center, size: size, angle: angle)
let rrect2 = RotatedRect(center: center2, size: size2, angle: angle2)
let rrect3 = rrect1
let clone1 = rrect1.clone()
let clone2 = rrect2.clone()
XCTAssert(rrect1 == rrect3)
XCTAssertFalse(rrect1 == rrect2)
XCTAssert(rrect2 == clone2)
clone2.angle = 10
XCTAssertFalse(rrect2 == clone2)
XCTAssert(rrect1 == clone1)
clone1.center.x += 1
XCTAssertFalse(rrect1 == clone1)
clone1.center.x -= 1
XCTAssert(rrect1 == clone1)
clone1.size.width += 1
XCTAssertFalse(rrect1 == clone1)
XCTAssertFalse(rrect1 == size)
}
func testHashCode() {
let rr = RotatedRect(center: center, size: size, angle: angle)
XCTAssertEqual(rr.hash(), rr.hash())
}
func testPoints() {
let rrect = RotatedRect(center: center, size: size, angle: angle);
let p = rrect.points()
let is_p0_irrational = (100 * p[0].x != round(100 * p[0].x)) && (100 * p[0].y != round(100 * p[0].y))
let is_p1_irrational = (100 * p[1].x != round(100 * p[1].x)) && (100 * p[1].y != round(100 * p[1].y));
let is_p2_irrational = (100 * p[2].x != round(100 * p[2].x)) && (100 * p[2].y != round(100 * p[2].y));
let is_p3_irrational = (100 * p[3].x != round(100 * p[3].x)) && (100 * p[3].y != round(100 * p[3].y));
XCTAssert(is_p0_irrational && is_p1_irrational && is_p2_irrational && is_p3_irrational)
XCTAssert(abs((p[0].x + p[2].x) / 2 - center.x) + abs((p[0].y + p[2].y) / 2 - center.y) < OpenCVTestCase.FEPS, "Symmetric points 0 and 2")
XCTAssert(abs((p[1].x + p[3].x) / 2 - center.x) + abs((p[1].y + p[3].y) / 2 - center.y) < OpenCVTestCase.FEPS, "Symmetric points 1 and 3")
XCTAssert(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)) < OpenCVTestCase.FEPS, "Orthogonal vectors 01 and 12")
XCTAssert(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)) < OpenCVTestCase.FEPS, "Orthogonal vectors 12 and 23");
XCTAssert(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)) < OpenCVTestCase.FEPS, "Orthogonal vectors 23 and 30")
XCTAssert(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)) < OpenCVTestCase.FEPS, "Orthogonal vectors 30 and 01")
XCTAssert(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) < OpenCVTestCase.FEPS, "Length of the vector 01")
XCTAssert(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) < OpenCVTestCase.FEPS, "Length of the vector 21")
XCTAssert(abs((p[2].x - p[1].x) / size.width - Float(cos(angle * Double.pi / 180))) < OpenCVTestCase.FEPS, "Angle of the vector 21 with the axes");
}
func testRotatedRect() {
let rr = RotatedRect()
XCTAssertNotNil(rr)
XCTAssertNotNil(rr.center)
XCTAssertNotNil(rr.size)
XCTAssertEqual(0.0, rr.angle)
}
func testRotatedRectDoubleArray() {
let vals = [1.5, 2.6, 3.7, 4.2, 5.1]
let rr = RotatedRect(vals: vals as [NSNumber])
XCTAssertNotNil(rr)
XCTAssertEqual(1.5, rr.center.x)
XCTAssertEqual(2.6, rr.center.y)
XCTAssertEqual(3.7, rr.size.width)
XCTAssertEqual(4.2, rr.size.height)
XCTAssertEqual(5.1, rr.angle)
}
func testRotatedRectPointSizeDouble() {
let rr = RotatedRect(center: center, size: size, angle: 40);
XCTAssertNotNil(rr)
XCTAssertNotNil(rr.center)
XCTAssertNotNil(rr.size)
XCTAssertEqual(40.0, rr.angle);
}
func testSet() {
let vals1: [Double] = []
let r1 = RotatedRect(center: center, size: size, angle: 40);
r1.set(vals: vals1 as [NSNumber])
XCTAssertEqual(0, r1.angle)
assertPoint2fEquals(Point2f(x: 0, y: 0), r1.center, OpenCVTestCase.FEPS)
assertSize2fEquals(Size2f(width: 0, height: 0), r1.size, OpenCVTestCase.FEPS)
let vals2 = [1, 2, 3, 4, 5]
let r2 = RotatedRect(center: center, size: size, angle: 40)
r2.set(vals: vals2 as [NSNumber])
XCTAssertEqual(5, r2.angle)
assertPoint2fEquals(Point2f(x: 1, y: 2), r2.center, OpenCVTestCase.FEPS)
assertSize2fEquals(Size2f(width: 3, height: 4), r2.size, OpenCVTestCase.FEPS)
}
func testToString() {
let actual = "\(RotatedRect(center: Point2f(x:1, y:2), size: Size2f(width:10, height:12), angle:4.5))"
let expected = "RotatedRect {Point2f {1.000000,2.000000},Size2f {10.000000,12.000000},4.500000}"
XCTAssertEqual(expected, actual);
}
}
|
