init - 初始化项目

modules/core/misc/objc/test/ConvertersTest.swift

@@ -0,0 +1,109 @@
+//
+//  ConvertersTest.swift
+//
+//  Created by Giles Payne on 2020/06/01.
+//
+
+import XCTest
+import OpenCV
+
+class ConvertersTest: OpenCVTestCase {
+
+    func testPoint2iToMat() {
+        let pointsIn = [Point(x:3, y:4), Point(x:6, y:7), Point(x:7, y:6), Point(x:-78, y:14), Point(x:-93, y:700)]
+        let pointsOut = Converters.Mat_to_vector_Point(Converters.vector_Point_to_Mat(pointsIn))
+        XCTAssertEqual(pointsIn, pointsOut)
+    }
+
+    func testPoint2fToMat() {
+        let pointsIn = [Point2f(x:3.8, y:4.2), Point2f(x:6.01, y:7), Point2f(x:7, y:6), Point2f(x:-78, y:14), Point2f(x:-93, y:700)]
+        let pointsOut = Converters.Mat_to_vector_Point2f(Converters.vector_Point2f_to_Mat(pointsIn))
+        XCTAssertEqual(pointsIn, pointsOut)
+    }
+
+    func testPoint2dToMat() {
+        let pointsIn = [Point2d(x:3.80004, y:73.2), Point2d(x:16.01, y:7.1111), Point2d(x:3.14, y:6), Point2d(x:-78, y:14)]
+        let pointsOut = Converters.Mat_to_vector_Point2d(Converters.vector_Point2d_to_Mat(pointsIn))
+        XCTAssertEqual(pointsIn, pointsOut)
+    }
+
+    func testPoint3iToMat() {
+        let pointsIn = [Point3i(x:3, y:4, z:2), Point3i(x:6, y:7, z:1), Point3i(x:7, y:6, z:9), Point3i(x:-78, y:14, z:0), Point3i(x:-93, y:700, z:54)]
+        let pointsOut = Converters.Mat_to_vector_Point3i(Converters.vector_Point3i_to_Mat(pointsIn))
+        XCTAssertEqual(pointsIn, pointsOut)
+    }
+
+    func testPoint3fToMat() {
+        let pointsIn = [Point3f(x:3.8, y:4.2, z:1200), Point3f(x:6.01, y:7, z: 12), Point3f(x:7, y:6, z:8.88128), Point3f(x:-78, y:14, z:-1), Point3f(x:-93, y:700, z:200)]
+        let pointsOut = Converters.Mat_to_vector_Point3f(Converters.vector_Point3f_to_Mat(pointsIn))
+        XCTAssertEqual(pointsIn, pointsOut)
+    }
+
+    func testPoint3dToMat() {
+        let pointsIn = [Point3d(x:3.80004, y:73.2, z:1), Point3d(x:16.01, y:7.1111, z:2), Point3d(x:3.14, y:6, z:3), Point3d(x:-78, y:14, z:4)]
+        let pointsOut = Converters.Mat_to_vector_Point3d(Converters.vector_Point3d_to_Mat(pointsIn))
+        XCTAssertEqual(pointsIn, pointsOut)
+    }
+
+    func testFloatToMat() {
+        let floatsIn:[Float] = [23.8, 999.89, 93, 0.9, 12]
+        let floatsOut = Converters.Mat_to_vector_float(Converters.vector_float_to_Mat(floatsIn as [NSNumber])) as! [Float]
+        XCTAssertEqual(floatsIn, floatsOut)
+    }
+
+    func testIntToMat() {
+        let intsIn:[Int32] = [23, 999, -93, 0, 4412]
+        let intsOut = Converters.Mat_to_vector_int(Converters.vector_int_to_Mat(intsIn as [NSNumber])) as! [Int32]
+        XCTAssertEqual(intsIn, intsOut)
+    }
+
+    func testCharToMat() {
+        let charsIn:[Int8] = [23, -23, 93, 0, -127]
+        let charsOut = Converters.Mat_to_vector_char(Converters.vector_char_to_Mat(charsIn as [NSNumber])) as! [Int8]
+        XCTAssertEqual(charsIn, charsOut)
+    }
+
+    func testUCharToMat() {
+        let ucharsIn:[UInt8] = [23, 190, 93, 0, 255]
+        let ucharsOut = Converters.Mat_to_vector_uchar(Converters.vector_uchar_to_Mat(ucharsIn as [NSNumber])) as! [UInt8]
+        XCTAssertEqual(ucharsIn, ucharsOut)
+    }
+
+    func testDoubleToMat() {
+        let doublesIn:[Double] = [23.8, 999.89, 93, 0.9, 12]
+        let doublesOut = Converters.Mat_to_vector_double(Converters.vector_double_to_Mat(doublesIn as [NSNumber])) as! [Double]
+        XCTAssertEqual(doublesIn, doublesOut)
+    }
+
+    func testRectToMat() {
+        let rectsIn = [Rect(x: 0, y: 0, width: 3, height: 4), Rect(x: 10, y: 23, width: 7, height: 6), Rect(x: 0, y: 1111110, width: 1, height: 4000)]
+        let rectsOut = Converters.Mat_to_vector_Rect(Converters.vector_Rect_to_Mat(rectsIn))
+        XCTAssertEqual(rectsIn, rectsOut)
+    }
+
+    func testRect2dToMat() {
+        let rectsIn = [Rect2d(x: 0.001, y: 0.00001, width: 3.2, height: 4.556555555), Rect2d(x: 10.009, y: -6623, width: 7.9, height: 6), Rect2d(x: 0, y: 1111.33110, width: 0.99999, height: 3999.999)]
+        let rectsOut = Converters.Mat_to_vector_Rect2d(Converters.vector_Rect2d_to_Mat(rectsIn))
+        XCTAssertEqual(rectsIn, rectsOut)
+    }
+
+    func testKeyPointToMat() {
+        let keyPointsIn = [KeyPoint(x: 8.99, y: 9.00, size: 3, angle: 3.23, response: 0.001, octave: 3, classId: 5), KeyPoint(x: 58.99, y: 9.488, size: 3.4, angle: 2.223, response: 0.006, octave: 4, classId: 7), KeyPoint(x: 7, y: 9.003, size: 12, angle: -3.23, response: 0.02, octave: 1, classId: 8)]
+        let keyPointsOut = Converters.Mat_to_vector_KeyPoint(Converters.vector_KeyPoint_to_Mat(keyPointsIn))
+        XCTAssertEqual(keyPointsIn, keyPointsOut)
+    }
+
+    func testDMatchToMat() {
+        let dmatchesIn = [DMatch(queryIdx: 2, trainIdx: 4, distance: 0.7), DMatch(queryIdx: 3, trainIdx: 7, distance: 0.1), DMatch(queryIdx: 4, trainIdx: 8, distance: 0.01)]
+        let dmatchesOut = Converters.Mat_to_vector_DMatch(Converters.vector_DMatch_to_Mat(dmatchesIn))
+        XCTAssertEqual(dmatchesIn, dmatchesOut)
+    }
+
+    func testRotatedRectToMat() {
+        let rectsIn = [RotatedRect(center: Point2f(x: 0.4, y: 0.9), size: Size2f(width: 3.0, height: 8.9), angle: 0.3342)]
+        let rectsOut = Converters.Mat_to_vector_RotatedRect(Converters.vector_RotatedRect_to_Mat(rectsIn))
+        XCTAssertEqual(rectsIn[0].center, rectsOut[0].center)
+        XCTAssertEqual(rectsIn[0].size, rectsOut[0].size)
+        XCTAssertEqual(rectsIn[0].angle, rectsOut[0].angle, accuracy: OpenCVTestCase.EPS)
+    }
+}

modules/core/misc/objc/test/CvTypeTest.swift

@@ -0,0 +1,75 @@
+//
+//  CvTypeTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class CvTypeTest: OpenCVTestCase {
+
+    func testMakeType() {
+        XCTAssertEqual(CvType.CV_8UC4, CvType.make(CvType.CV_8U, channels: 4))
+    }
+
+    func testCV_8UC() {
+        XCTAssertEqual(CvType.CV_8UC4, CvType.CV_8UC(4))
+    }
+
+    func testCV_8SC() {
+        XCTAssertEqual(CvType.CV_8SC4, CvType.CV_8SC(4))
+    }
+
+    func testCV_16UC() {
+        XCTAssertEqual(CvType.CV_16UC4, CvType.CV_16UC(4))
+    }
+
+    func testCV_16SC() {
+        XCTAssertEqual(CvType.CV_16SC4, CvType.CV_16SC(4))
+    }
+
+    func testCV_32SC() {
+        XCTAssertEqual(CvType.CV_32SC4, CvType.CV_32SC(4))
+    }
+
+    func testCV_32FC() {
+        XCTAssertEqual(CvType.CV_32FC4, CvType.CV_32FC(4))
+    }
+
+    func testCV_64FC() {
+        XCTAssertEqual(CvType.CV_64FC4, CvType.CV_64FC(4))
+    }
+
+    func testCV_16FC() {
+        XCTAssertEqual(CvType.CV_16FC1, CvType.CV_16FC(1))
+        XCTAssertEqual(CvType.CV_16FC2, CvType.CV_16FC(2))
+        XCTAssertEqual(CvType.CV_16FC3, CvType.CV_16FC(3))
+        XCTAssertEqual(CvType.CV_16FC4, CvType.CV_16FC(4))
+    }
+
+    func testChannels() {
+        XCTAssertEqual(1, CvType.channels(CvType.CV_64F))
+    }
+
+    func testDepth() {
+        XCTAssertEqual(CvType.CV_64F, CvType.depth(CvType.CV_64FC3))
+    }
+
+    func testIsInteger() {
+        XCTAssertFalse(CvType.isInteger(CvType.CV_32FC3));
+        XCTAssert(CvType.isInteger(CvType.CV_16S));
+    }
+
+    func testELEM_SIZE() {
+        XCTAssertEqual(3 * 8, CvType.elemSize(CvType.CV_64FC3));
+        XCTAssertEqual(3 * 2, CvType.elemSize(CvType.CV_16FC3));
+    }
+
+    func testTypeToString() {
+        XCTAssertEqual("CV_32FC1", CvType.type(toString: CvType.CV_32F));
+        XCTAssertEqual("CV_32FC3", CvType.type(toString: CvType.CV_32FC3));
+        XCTAssertEqual("CV_32FC(128)", CvType.type(toString: CvType.CV_32FC(128)));
+    }
+
+}

modules/core/misc/objc/test/DMatchTest.swift

@@ -0,0 +1,44 @@
+//
+//  DMatchTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class DMatchTest: OpenCVTestCase {
+
+    func testDMatchIntIntFloat() {
+        let dm1 = DMatch(queryIdx: 1, trainIdx: 4, distance: 4.0)
+
+        XCTAssertEqual(1, dm1.queryIdx)
+        XCTAssertEqual(4, dm1.trainIdx)
+        XCTAssertEqual(4.0, dm1.distance)
+    }
+
+    func testDMatchIntIntIntFloat() {
+        let dm2 = DMatch(queryIdx: 2, trainIdx: 6, imgIdx: -1, distance: 8.0)
+
+        XCTAssertEqual(2, dm2.queryIdx)
+        XCTAssertEqual(6, dm2.trainIdx)
+        XCTAssertEqual(-1, dm2.imgIdx)
+        XCTAssertEqual(8.0, dm2.distance)
+    }
+
+    func testLessThan() {
+        let dm1 = DMatch(queryIdx: 1, trainIdx: 4, distance: 4.0)
+        let dm2 = DMatch(queryIdx: 2, trainIdx: 6, imgIdx: -1, distance: 8.0)
+        XCTAssert(dm1.lessThan(dm2))
+    }
+
+    func testToString() {
+        let dm2 = DMatch(queryIdx: 2, trainIdx: 6, imgIdx: -1, distance: 8.0)
+
+        let actual = "\(dm2)"
+
+        let expected = "DMatch { queryIdx: 2, trainIdx: 6, imgIdx: -1, distance: 8.000000}"
+        XCTAssertEqual(expected, actual)
+    }
+
+}

modules/core/misc/objc/test/KeyPointTest.swift

@@ -0,0 +1,59 @@
+//
+//  KeyPointTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class KeyPointTest: OpenCVTestCase {
+
+    let angle:Float = 30
+    let classId:Int32 = 1
+    let octave:Int32 = 1
+    let response:Float = 2.0
+    let size:Float = 3.0
+    let x:Float = 1.0
+    let y:Float = 2.0
+
+    func testKeyPoint() {
+        let keyPoint = KeyPoint()
+        assertPoint2fEquals(Point2f(x: 0, y: 0), keyPoint.pt, OpenCVTestCase.FEPS)
+    }
+
+    func testKeyPointFloatFloatFloat() {
+        let keyPoint = KeyPoint(x: x, y: y, size: size)
+        assertPoint2fEquals(Point2f(x: 1, y: 2), keyPoint.pt, OpenCVTestCase.FEPS)
+    }
+
+    func testKeyPointFloatFloatFloatFloat() {
+        let keyPoint = KeyPoint(x: x, y: y, size: size, angle: 10.0)
+        XCTAssertEqual(10.0, keyPoint.angle);
+    }
+
+    func testKeyPointFloatFloatFloatFloatFloat() {
+        let keyPoint = KeyPoint(x: x, y: y, size: size, angle: 1.0, response: 1.0)
+        XCTAssertEqual(1.0, keyPoint.response)
+    }
+
+    func testKeyPointFloatFloatFloatFloatFloatInt() {
+        let keyPoint = KeyPoint(x: x, y: y, size: size, angle: 1.0, response: 1.0, octave: 1)
+        XCTAssertEqual(1, keyPoint.octave)
+    }
+
+    func testKeyPointFloatFloatFloatFloatFloatIntInt() {
+        let keyPoint = KeyPoint(x: x, y: y, size: size, angle: 1.0, response: 1.0, octave: 1, classId: 1)
+        XCTAssertEqual(1, keyPoint.classId)
+    }
+
+    func testToString() {
+        let keyPoint = KeyPoint(x: x, y: y, size: size, angle: angle, response: response, octave: octave, classId: classId)
+
+        let actual = "\(keyPoint)"
+
+        let expected = "KeyPoint { pt: Point2f {1.000000,2.000000}, size: 3.000000, angle: 30.000000, response: 2.000000, octave: 1, classId: 1}"
+        XCTAssertEqual(expected, actual)
+    }
+
+}

modules/core/misc/objc/test/MatTestObjc.m

@@ -0,0 +1,58 @@
+//
+//  MatTests.m
+//
+//  Created by Giles Payne on 2020/01/25.
+//
+
+#import <XCTest/XCTest.h>
+#import <OpenCV/OpenCV.h>
+
+#define CV_8U 0
+#define CV_16S 3
+#define CV_32S 4
+#define CV_32F 5
+#define CV_CN_SHIFT 3
+#define CV_DEPTH_MAX (1 << CV_CN_SHIFT)
+#define CV_MAT_DEPTH_MASK (CV_DEPTH_MAX - 1)
+#define CV_MAT_DEPTH(flags) ((flags) & CV_MAT_DEPTH_MASK)
+#define CV_MAKETYPE(depth,cn) (CV_MAT_DEPTH(depth) + (((cn)-1) << CV_CN_SHIFT))
+#define CV_8UC3 CV_MAKETYPE(CV_8U,3)
+#define CV_32FC3 CV_MAKETYPE(CV_32F,3)
+#define CV_32SC3 CV_MAKETYPE(CV_32S,3)
+#define CV_16SC3 CV_MAKETYPE(CV_16S,3)
+
+@interface MatTestsObjc : XCTestCase
+
+@end
+
+@implementation MatTestsObjc
+
+// XCTAssertThrows only works in Objective-C so these tests are separate from the main MatTest.swift
+- (void)testBadData {
+    Mat* m1 = [[Mat alloc] initWithRows:5 cols:5 type:CV_8UC3];
+    Mat* m2 = [[Mat alloc] initWithSizes:@[@5, @5, @5] type:CV_8UC3];
+    Mat* m3 = [[Mat alloc] initWithRows:5 cols:5 type:CV_32FC3];
+    Mat* m4 = [[Mat alloc] initWithSizes:@[@5, @5, @5] type:CV_32FC3];
+    Mat* m5 = [[Mat alloc] initWithRows:5 cols:5 type:CV_32SC3];
+    Mat* m6 = [[Mat alloc] initWithSizes:@[@5, @5, @5] type:CV_32SC3];
+    Mat* m7 = [[Mat alloc] initWithRows:5 cols:5 type:CV_16SC3];
+    Mat* m8 = [[Mat alloc] initWithSizes:@[@5, @5, @5] type:CV_16SC3];
+    NSMutableArray<NSNumber*>* badData7 = [NSMutableArray arrayWithArray: @[@0, @0, @0, @0, @0, @0, @0]];
+    NSMutableArray<NSNumber*>* badData5 = [NSMutableArray arrayWithArray: @[@0, @0, @0, @0, @0]];
+
+    XCTAssertThrows([m1 get: 2 col: 2 data: badData7]);
+    XCTAssertThrows([m1 put: 2 col: 2 data: badData5]);
+    XCTAssertThrows([m2 put:(@[@2, @2, @0]) data: badData5]);
+    XCTAssertThrows([m3 put: 2 col: 2 data: badData5]);
+    XCTAssertThrows([m4 put:(@[@4, @2, @2]) data: badData5]);
+    XCTAssertThrows([m5 put: 2 col: 2 data: badData5]);
+    XCTAssertThrows([m6 put:(@[@2, @2, @0]) data: badData5]);
+    XCTAssertThrows([m7 put: 2 col: 2 data: badData5]);
+    XCTAssertThrows([m8 put:(@[@2, @2, @0]) data: badData5]);
+}
+
+- (void)testRelease {
+    Mat* m = [[Mat alloc] initWithRows:5 cols:5 type:CV_8UC3];
+    XCTAssertNoThrow(m = nil);
+}
+@end

modules/core/misc/objc/test/Point3Test.swift

@@ -0,0 +1,101 @@
+//
+//  Point3Test.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class Point3Test: OpenCVTestCase {
+
+    let p1 = Point3i(x: 2, y: 2, z: 2)
+    let p2 = Point3i(x: 1, y: 1, z: 1)
+
+    func testClone() {
+        let truth = Point3i(x: 1, y: 1, z: 1)
+        let p1 = truth.clone()
+        XCTAssertEqual(truth, p1)
+    }
+
+    func testCross() {
+        let dstPoint = p1.cross(p2)
+        let truth = Point3i(x: 0, y: 0, z: 0)
+        XCTAssertEqual(truth, dstPoint)
+    }
+
+    func testDot() {
+        let result = p1.dot(p2)
+        XCTAssertEqual(6.0, result)
+    }
+
+    func testEqualsObject() {
+        var flag = p1 == p1
+        XCTAssert(flag)
+
+        flag = p1 == p2
+        XCTAssertFalse(flag)
+    }
+
+    func testHashCode() {
+        XCTAssertEqual(p1.hash(), p1.hash())
+    }
+
+    func testPoint3() {
+        let p1 = Point3i()
+
+        XCTAssertNotNil(p1)
+        XCTAssert(0 == p1.x)
+        XCTAssert(0 == p1.y)
+        XCTAssert(0 == p1.z)
+    }
+
+    func testPoint3DoubleArray() {
+        let vals:[Double] = [1, 2, 3]
+        let p1 = Point3i(vals: vals as [NSNumber])
+
+        XCTAssert(1 == p1.x)
+        XCTAssert(2 == p1.y)
+        XCTAssert(3 == p1.z)
+    }
+
+    func testPoint3DoubleDoubleDouble() {
+        let p1 = Point3i(x: 1, y: 2, z: 3)
+
+        XCTAssertEqual(1, p1.x)
+        XCTAssertEqual(2, p1.y)
+        XCTAssertEqual(3, p1.z)
+    }
+
+    func testPoint3Point() {
+        let p = Point(x: 2, y: 3)
+        let p1 = Point3i(point: p)
+
+        XCTAssertEqual(2, p1.x)
+        XCTAssertEqual(3, p1.y)
+        XCTAssertEqual(0, p1.z)
+    }
+
+    func testSet() {
+        let vals1:[Double] = []
+        p1.set(vals: vals1 as [NSNumber]);
+
+        XCTAssertEqual(0, p1.x)
+        XCTAssertEqual(0, p1.y)
+        XCTAssertEqual(0, p1.z)
+
+        let vals2 = [3, 6, 10]
+        p1.set(vals: vals2 as [NSNumber])
+
+        XCTAssertEqual(3, p1.x)
+        XCTAssertEqual(6, p1.y)
+        XCTAssertEqual(10, p1.z)
+    }
+
+    func testToString() {
+        let actual = "\(p1)"
+        let expected = "Point3i {2,2,2}"
+        XCTAssertEqual(expected, actual)
+    }
+
+}

modules/core/misc/objc/test/PointTest.swift

@@ -0,0 +1,88 @@
+//
+//  PointTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class PointTest: OpenCVTestCase {
+
+    let p1 = Point2d(x: 2, y: 2)
+    let p2 = Point2d(x: 1, y: 1)
+
+    func testClone() {
+        let truth = Point2d(x: 1, y: 1)
+        let dstPoint = truth.clone()
+        XCTAssertEqual(truth, dstPoint);
+    }
+
+    func testDot() {
+        let result = p1.dot(p2);
+        XCTAssertEqual(4.0, result)
+    }
+
+    func testEqualsObject() {
+        var flag = p1 == p1
+        XCTAssert(flag)
+
+        flag = p1 == p2
+        XCTAssertFalse(flag)
+    }
+
+    func testHashCode() {
+        XCTAssertEqual(p1.hash(), p1.hash())
+    }
+
+    func testInside() {
+        let rect =  Rect2d(x: 0, y: 0, width: 5, height: 3)
+        XCTAssert(p1.inside(rect))
+
+        let p2 = Point2d(x: 3, y: 3)
+        XCTAssertFalse(p2.inside(rect))
+    }
+
+    func testPoint() {
+        let p = Point2d()
+
+        XCTAssertNotNil(p)
+        XCTAssertEqual(0.0, p.x)
+        XCTAssertEqual(0.0, p.y)
+    }
+
+    func testPointDoubleArray() {
+        let vals:[Double] =  [2, 4]
+        let p = Point2d(vals: vals as [NSNumber])
+
+        XCTAssertEqual(2.0, p.x);
+        XCTAssertEqual(4.0, p.y);
+    }
+
+    func testPointDoubleDouble() {
+        let p1 = Point2d(x: 7, y: 5)
+
+        XCTAssertNotNil(p1)
+        XCTAssertEqual(7.0, p1.x);
+        XCTAssertEqual(5.0, p1.y);
+    }
+
+    func testSet() {
+        let vals1:[Double] = []
+        p1.set(vals: vals1 as [NSNumber])
+        XCTAssertEqual(0.0, p1.x)
+        XCTAssertEqual(0.0, p1.y)
+
+        let vals2 = [ 6, 10 ]
+        p2.set(vals: vals2 as [NSNumber])
+        XCTAssertEqual(6.0, p2.x)
+        XCTAssertEqual(10.0, p2.y)
+    }
+
+    func testToString() {
+        let actual = "\(p1)"
+        let expected = "Point2d {2.000000,2.000000}"
+        XCTAssertEqual(expected, actual)
+    }
+
+}

modules/core/misc/objc/test/RangeTest.swift

@@ -0,0 +1,104 @@
+//
+//  RangeTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class RangeTest: OpenCVTestCase {
+
+    let r1 = Range(start: 1, end: 11)
+    let r2 = Range(start: 1, end: 1)
+
+    func testAll() {
+        let range = Range.all()
+        XCTAssertEqual(Int32.min, range.start)
+        XCTAssertEqual(Int32.max, range.end)
+    }
+
+    func testClone() {
+        let dstRange = r1.clone()
+        XCTAssertEqual(r1, dstRange)
+    }
+
+    func testEmpty() {
+        var flag = r1.empty()
+        XCTAssertFalse(flag)
+
+        flag = r2.empty()
+        XCTAssert(flag)
+    }
+
+    func testEqualsObject() {
+        XCTAssertFalse(r2 == r1)
+
+        let range = r1.clone()
+        XCTAssert(r1 == range)
+    }
+
+    func testHashCode() {
+        XCTAssertEqual(r1.hash(), r1.hash())
+    }
+
+    func testIntersection() {
+        let range = r1.intersection(r2)
+        XCTAssertEqual(r2, range)
+    }
+
+    func testRange() {
+        let range = Range()
+
+        XCTAssertNotNil(range)
+        XCTAssertEqual(0, range.start)
+        XCTAssertEqual(0, range.end)
+    }
+
+    func testRangeDoubleArray() {
+        let vals:[Double] = [2, 4]
+        let r = Range(vals: vals as [NSNumber])
+
+        XCTAssert(2 == r.start);
+        XCTAssert(4 == r.end);
+    }
+
+    func testRangeIntInt() {
+        let r1 = Range(start: 12, end: 13)
+
+        XCTAssertNotNil(r1);
+        XCTAssertEqual(12, r1.start);
+        XCTAssertEqual(13, r1.end);
+    }
+
+    func testSet() {
+        let vals1:[Double] = []
+        r1.set(vals: vals1 as [NSNumber])
+        XCTAssertEqual(0, r1.start)
+        XCTAssertEqual(0, r1.end)
+
+        let vals2 = [6, 10]
+        r2.set(vals: vals2 as [NSNumber])
+        XCTAssertEqual(6, r2.start)
+        XCTAssertEqual(10, r2.end)
+    }
+
+    func testShift() {
+        let delta:Int32 = 1
+        let range = Range().shift(delta)
+        XCTAssertEqual(r2, range)
+    }
+
+    func testSize() {
+        XCTAssertEqual(10, r1.size())
+
+        XCTAssertEqual(0, r2.size())
+    }
+
+    func testToString() {
+        let actual = "\(r1)"
+        let expected = "Range {1, 11}"
+        XCTAssertEqual(expected, actual)
+    }
+
+}

modules/core/misc/objc/test/RectTest.swift

@@ -0,0 +1,153 @@
+//
+//  RectTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class RectTest: OpenCVTestCase {
+
+    let r = Rect()
+    let rect = Rect(x: 0, y: 0, width: 10, height: 10)
+
+    func testArea() {
+        let area = rect.area()
+        XCTAssertEqual(100.0, area)
+    }
+
+    func testBr() {
+        let p_br = rect.br()
+        let truth = Point(x: 10, y: 10)
+        XCTAssertEqual(truth, p_br)
+    }
+
+    func testClone() {
+        let r = rect.clone()
+        XCTAssertEqual(rect, r)
+    }
+
+    func testContains() {
+        let rect = Rect(x: 0, y: 0, width: 10, height: 10)
+
+        let p_inner = Point(x: 5, y: 5)
+        let p_outer = Point(x: 5, y: 55)
+        let p_bl = Point(x: 0, y: 0)
+        let p_br = Point(x: 10, y: 0)
+        let p_tl = Point(x: 0, y: 10)
+        let p_tr = Point(x: 10, y: 10)
+
+        XCTAssert(rect.contains(p_inner))
+        XCTAssert(rect.contains(p_bl))
+
+        XCTAssertFalse(rect.contains(p_outer))
+        XCTAssertFalse(rect.contains(p_br))
+        XCTAssertFalse(rect.contains(p_tl))
+        XCTAssertFalse(rect.contains(p_tr))
+    }
+
+    func testEqualsObject() {
+        var flag = rect == r
+        XCTAssertFalse(flag)
+
+        let r = rect.clone()
+        flag = rect == r
+        XCTAssert(flag)
+    }
+
+    func testHashCode() {
+        XCTAssertEqual(rect.hash(), rect.hash())
+    }
+
+    func testRect() {
+        let r = Rect()
+
+        XCTAssertEqual(0, r.x)
+        XCTAssertEqual(0, r.y)
+        XCTAssertEqual(0, r.width)
+        XCTAssertEqual(0, r.height)
+    }
+
+    func testRectDoubleArray() {
+        let vals:[Double] = [1, 3, 5, 2]
+        let r = Rect(vals: vals as [NSNumber])
+
+        XCTAssertEqual(1, r.x)
+        XCTAssertEqual(3, r.y)
+        XCTAssertEqual(5, r.width)
+        XCTAssertEqual(2, r.height)
+    }
+
+    func testRectIntIntIntInt() {
+        let rect = Rect(x: 1, y: 3, width: 5, height: 2)
+
+        XCTAssertNotNil(rect)
+        XCTAssertEqual(1, rect.x)
+        XCTAssertEqual(3, rect.y)
+        XCTAssertEqual(5, rect.width)
+        XCTAssertEqual(2, rect.height)
+    }
+
+    func testRectPointPoint() {
+        let p1 = Point(x:4, y:4)
+        let p2 = Point(x: 2, y: 3)
+
+        let r = Rect(point: p1, point: p2)
+        XCTAssertNotNil(r);
+        XCTAssertEqual(2, r.x);
+        XCTAssertEqual(3, r.y);
+        XCTAssertEqual(2, r.width);
+        XCTAssertEqual(1, r.height);
+    }
+
+    func testRectPointSize() {
+        let p1 = Point(x: 4, y: 4)
+        let sz = Size(width: 3, height: 1)
+        let r = Rect(point: p1, size: sz)
+
+        XCTAssertEqual(4, r.x)
+        XCTAssertEqual(4, r.y)
+        XCTAssertEqual(3, r.width)
+        XCTAssertEqual(1, r.height)
+    }
+
+    func testSet() {
+        let vals1:[Double] = []
+        let r1 = Rect(vals:vals1 as [NSNumber])
+
+        XCTAssertEqual(0, r1.x)
+        XCTAssertEqual(0, r1.y)
+        XCTAssertEqual(0, r1.width)
+        XCTAssertEqual(0, r1.height)
+
+        let vals2:[Double] = [2, 2, 10, 5]
+        let r = Rect(vals: vals2 as [NSNumber])
+
+        XCTAssertEqual(2, r.x)
+        XCTAssertEqual(2, r.y)
+        XCTAssertEqual(10, r.width)
+        XCTAssertEqual(5, r.height)
+    }
+
+    func testSize() {
+        let s1 = Size(width: 0, height: 0)
+        XCTAssertEqual(s1, r.size())
+
+        let s2 = Size(width: 10, height: 10)
+        XCTAssertEqual(s2, rect.size())
+    }
+
+    func testTl() {
+        let p_tl = rect.tl()
+        let truth = Point(x: 0, y: 0)
+        XCTAssertEqual(truth, p_tl)
+    }
+
+    func testToString() {
+        let actual = "\(rect)"
+        let expected = "Rect2i {0,0,10,10}"
+        XCTAssertEqual(expected, actual);
+    }
+
+}

modules/core/misc/objc/test/RotatedRectTest.swift

@@ -0,0 +1,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);
+    }
+
+}

modules/core/misc/objc/test/ScalarTest.swift

@@ -0,0 +1,98 @@
+//
+//  ScalarTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class ScalarTest: OpenCVTestCase {
+
+    let s1 = Scalar(1.0)
+    let s2 = Scalar.all(1.0)
+
+    func testAll() {
+        let dstScalar = Scalar.all(2.0)
+        let truth = Scalar(2.0, 2.0, 2.0, 2.0)
+        XCTAssertEqual(truth, dstScalar)
+    }
+
+    func testClone() {
+        let dstScalar = s2.clone()
+        XCTAssertEqual(s2, dstScalar)
+    }
+
+    func testConj() {
+        let dstScalar = s2.conj()
+        let truth = Scalar(1, -1, -1, -1)
+        XCTAssertEqual(truth, dstScalar)
+    }
+
+    func testEqualsObject() {
+        let dstScalar = s2.clone()
+        XCTAssert(s2 == dstScalar)
+
+        XCTAssertFalse(s2 == s1)
+    }
+
+    func testHashCode() {
+        XCTAssertEqual(s2.hash(), s2.hash())
+    }
+
+    func testIsReal() {
+        XCTAssert(s1.isReal())
+
+        XCTAssertFalse(s2.isReal())
+    }
+
+    func testMulScalar() {
+        let dstScalar = s2.mul(s1)
+        XCTAssertEqual(s1, dstScalar)
+    }
+
+    func testMulScalarDouble() {
+        let multiplier = 2.0
+        let dstScalar = s2.mul(s1, scale: multiplier)
+        let truth = Scalar(2)
+        XCTAssertEqual(truth, dstScalar)
+    }
+
+    func testScalarDouble() {
+        let truth = Scalar(1)
+        XCTAssertEqual(truth, s1)
+    }
+
+    func testScalarDoubleArray() {
+        let vals: [Double] = [2.0, 4.0, 5.0, 3.0]
+        let dstScalar = Scalar(vals:vals as [NSNumber])
+
+        let truth = Scalar(2.0, 4.0, 5.0, 3.0)
+        XCTAssertEqual(truth, dstScalar)
+    }
+
+    func testScalarDoubleDouble() {
+        let dstScalar = Scalar(2, 5)
+        let truth = Scalar(2.0, 5.0, 0.0, 0.0)
+        XCTAssertEqual(truth, dstScalar)
+    }
+
+    func testScalarDoubleDoubleDouble() {
+        let dstScalar = Scalar(2.0, 5.0, 5.0)
+        let truth = Scalar(2.0, 5.0, 5.0, 0.0)
+        XCTAssertEqual(truth, dstScalar);
+    }
+
+    func testScalarDoubleDoubleDoubleDouble() {
+        let dstScalar = Scalar(2.0, 5.0, 5.0, 9.0)
+        let truth = Scalar(2.0, 5.0, 5.0, 9.0)
+        XCTAssertEqual(truth, dstScalar)
+    }
+
+    func testToString() {
+        let actual = "\(s2)"
+        let expected = "Scalar [1.000000, 1.000000, 1.000000, 1.000000]"
+        XCTAssertEqual(expected, actual)
+    }
+
+}

modules/core/misc/objc/test/SizeTest.swift

@@ -0,0 +1,86 @@
+//
+//  SizeTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class SizeTest: OpenCVTestCase {
+
+    let sz1 = Size2d(width: 10.0, height: 10.0)
+    let sz2 = Size2d(width: -1, height: -1)
+
+    func testArea() {
+        let area = sz1.area()
+        XCTAssertEqual(100.0, area);
+    }
+
+    func testClone() {
+        let dstSize = sz1.clone()
+        XCTAssertEqual(sz1, dstSize)
+    }
+
+    func testEqualsObject() {
+        XCTAssertFalse(sz1 == sz2);
+
+        let sz2 = sz1.clone();
+        XCTAssertTrue(sz1 == sz2);
+    }
+
+    func testHashCode() {
+        XCTAssertEqual(sz1.hash(), sz1.hash());
+    }
+
+    func testSet() {
+        let vals1:[Double] = []
+        sz2.set(vals: vals1 as [NSNumber])
+        XCTAssertEqual(0, sz2.width);
+        XCTAssertEqual(0, sz2.height);
+
+        let vals2:[Double] = [9, 12]
+        sz1.set(vals: vals2 as [NSNumber]);
+        XCTAssertEqual(9, sz1.width);
+        XCTAssertEqual(12, sz1.height);
+    }
+
+    func testSize() {
+        let dstSize = Size2d()
+
+        XCTAssertNotNil(dstSize)
+        XCTAssertEqual(0, dstSize.width)
+        XCTAssertEqual(0, dstSize.height)
+    }
+
+    func testSizeDoubleArray() {
+        let vals:[Double] = [10, 20]
+        let sz2 = Size2d(vals: vals as [NSNumber])
+
+        XCTAssertEqual(10, sz2.width)
+        XCTAssertEqual(20, sz2.height)
+    }
+
+    func testSizeDoubleDouble() {
+        XCTAssertNotNil(sz1)
+
+        XCTAssertEqual(10.0, sz1.width)
+        XCTAssertEqual(10.0, sz1.height)
+    }
+
+    func testSizePoint() {
+        let p = Point2d(x: 2, y: 4)
+        let sz1 = Size2d(point: p)
+
+        XCTAssertNotNil(sz1)
+        XCTAssertEqual(2.0, sz1.width)
+        XCTAssertEqual(4.0, sz1.height)
+    }
+
+    func testToString() {
+        let actual = "\(sz1)"
+        let expected = "Size2d {10.000000,10.000000}"
+        XCTAssertEqual(expected, actual);
+    }
+
+}

modules/core/misc/objc/test/TermCriteriaTest.swift

@@ -0,0 +1,82 @@
+//
+//  TermCriteriaTest.swift
+//
+//  Created by Giles Payne on 2020/01/31.
+//
+
+import XCTest
+import OpenCV
+
+class TermCriteriaTest: OpenCVTestCase {
+
+    let tc2 = TermCriteria(type: 2, maxCount: 4, epsilon: EPS)
+
+    func testClone() {
+        let tc1 = tc2.clone()
+        XCTAssertEqual(tc2, tc1)
+    }
+
+    func testEqualsObject() {
+        var tc1 = TermCriteria()
+        XCTAssertFalse(tc2 == tc1)
+
+        tc1 = tc2.clone()
+        XCTAssert(tc2 == tc1)
+    }
+
+    func testHashCode() {
+        XCTAssertEqual(tc2.hash(), tc2.hash())
+    }
+
+    func testSet() {
+        let tc1 = TermCriteria()
+        let vals1:[Double] = []
+
+        tc1.set(vals: vals1 as [NSNumber])
+
+        XCTAssertEqual(0, tc1.type)
+        XCTAssertEqual(0, tc1.maxCount)
+        XCTAssertEqual(0.0, tc1.epsilon)
+
+        let vals2 = [9, 8, 0.002]
+        tc2.set(vals: vals2 as [NSNumber])
+
+        XCTAssertEqual(9, tc2.type)
+        XCTAssertEqual(8, tc2.maxCount)
+        XCTAssertEqual(0.002, tc2.epsilon)
+    }
+
+    func testTermCriteria() {
+        let tc1 = TermCriteria()
+
+        XCTAssertNotNil(tc1)
+        XCTAssertEqual(0, tc1.type)
+        XCTAssertEqual(0, tc1.maxCount)
+        XCTAssertEqual(0.0, tc1.epsilon)
+    }
+
+    func testTermCriteriaDoubleArray() {
+        let vals = [ 3, 2, 0.007]
+        let tc1 = TermCriteria(vals: vals as [NSNumber])
+
+        XCTAssertEqual(3, tc1.type)
+        XCTAssertEqual(2, tc1.maxCount)
+        XCTAssertEqual(0.007, tc1.epsilon)
+    }
+
+    func testTermCriteriaIntIntDouble() {
+        let tc1 = TermCriteria(type: 2, maxCount: 4, epsilon: OpenCVTestCase.EPS)
+
+        XCTAssertNotNil(tc1)
+        XCTAssertEqual(2, tc1.type)
+        XCTAssertEqual(4, tc1.maxCount)
+        XCTAssertEqual(OpenCVTestCase.EPS, tc1.epsilon)
+    }
+
+    func testToString() {
+        let actual = "\(tc2)"
+        let expected = "TermCriteria { type: 2, maxCount: 4, epsilon: 0.001000}"
+        XCTAssertEqual(expected, actual)
+    }
+
+}