mirror of
https://github.com/opencv/opencv.git
synced 2025-01-07 19:54:18 +08:00
227 lines
11 KiB
Swift
227 lines
11 KiB
Swift
//
|
|
// OpenCVTestCase.swift
|
|
//
|
|
// Created by Giles Payne on 2020/01/19.
|
|
//
|
|
|
|
import XCTest
|
|
import OpenCV
|
|
|
|
enum OpenCVTestError: Error {
|
|
case unsupportedOperationError(String)
|
|
}
|
|
|
|
open class OpenCVTestCase: XCTestCase {
|
|
|
|
//change to 'true' to unblock fail on fail("Not yet implemented")
|
|
static let passNYI = true
|
|
|
|
static let isTestCaseEnabled = true
|
|
|
|
static let XFEATURES2D = "xfeatures2d"
|
|
static let DEFAULT_FACTORY = "create"
|
|
|
|
static let matSize: Int32 = 10
|
|
static let EPS = 0.001
|
|
static let FEPS:Float = 0.001
|
|
static let weakEPS = 0.5
|
|
static let weakFEPS:Float = 0.5
|
|
|
|
var dst: Mat = Mat()
|
|
var truth: Mat? = nil
|
|
|
|
let colorBlack = Scalar(0)
|
|
let colorWhite = Scalar(255, 255, 255)
|
|
|
|
// Naming notation: <channels info>_[depth]_[dimensions]_value
|
|
// examples: gray0 - single channel 8U 2d Mat filled with 0
|
|
// grayRnd - single channel 8U 2d Mat filled with random numbers
|
|
// gray0_32f_1d
|
|
|
|
let gray0 = Mat(rows:matSize, cols:matSize, type:CvType.CV_8U, scalar:Scalar(0))
|
|
let gray1 = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U, scalar: Scalar(1))
|
|
let gray2 = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U, scalar: Scalar(2))
|
|
let gray3 = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U, scalar: Scalar(3))
|
|
let gray9 = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U, scalar: Scalar(9))
|
|
let gray127 = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U, scalar: Scalar(127))
|
|
let gray128 = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U, scalar: Scalar(128))
|
|
let gray255 = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U, scalar: Scalar(255))
|
|
let grayRnd = Mat(rows:matSize, cols:matSize, type: CvType.CV_8U)
|
|
|
|
let gray_16u_256 = Mat(rows: matSize, cols: matSize, type: CvType.CV_16U, scalar: Scalar(256))
|
|
let gray_16s_1024 = Mat(rows: matSize, cols: matSize, type: CvType.CV_16S, scalar: Scalar(1024))
|
|
|
|
let gray0_32f = Mat(rows: matSize, cols: matSize, type: CvType.CV_32F, scalar: Scalar(0.0))
|
|
let gray1_32f = Mat(rows: matSize, cols: matSize, type: CvType.CV_32F, scalar: Scalar(1.0))
|
|
let gray3_32f = Mat(rows: matSize, cols: matSize, type: CvType.CV_32F, scalar: Scalar(3.0))
|
|
let gray9_32f = Mat(rows: matSize, cols: matSize, type: CvType.CV_32F, scalar: Scalar(9.0))
|
|
let gray255_32f = Mat(rows: matSize, cols: matSize, type: CvType.CV_32F, scalar: Scalar(255.0))
|
|
let grayE_32f = Mat.eye(rows: matSize, cols: matSize, type: CvType.CV_32FC1)
|
|
let grayRnd_32f = Mat(rows: matSize, cols: matSize, type: CvType.CV_32F)
|
|
|
|
let gray0_64f = Mat(rows: matSize, cols: matSize, type: CvType.CV_64F, scalar: Scalar(0.0))
|
|
let gray0_32f_1d = Mat(rows: 1, cols: matSize, type: CvType.CV_32F, scalar: Scalar(0.0))
|
|
let gray0_64f_1d = Mat(rows: 1, cols: matSize, type: CvType.CV_64F, scalar: Scalar(0.0))
|
|
|
|
let rgba0 = Mat(rows: matSize, cols: matSize, type: CvType.CV_8UC4, scalar: Scalar.all(0))
|
|
let rgba128 = Mat(rows: matSize, cols: matSize, type: CvType.CV_8UC4, scalar: Scalar.all(128))
|
|
|
|
let rgbLena: Mat = {
|
|
return Imgcodecs.imread(filename: Bundle(for: OpenCVTestCase.self).path(forResource:"lena", ofType:"png", inDirectory:"resources")!)
|
|
}()
|
|
|
|
let grayChess: Mat = {
|
|
return Imgcodecs.imread(filename: Bundle(for: OpenCVTestCase.self).path(forResource:"chessboard", ofType:"jpg", inDirectory:"resources")!, flags: ImreadModes.IMREAD_GRAYSCALE.rawValue)
|
|
}()
|
|
|
|
let gray255_32f_3d = Mat(sizes: [matSize, matSize, matSize] as [NSNumber], type: CvType.CV_32F, scalar: Scalar(255.0))
|
|
|
|
let v1 = Mat(rows: 1, cols: 3, type: CvType.CV_32F)
|
|
let v2 = Mat(rows: 1, cols: 3, type: CvType.CV_32F)
|
|
|
|
override open func setUp() {
|
|
//Core.setErrorVerbosity(false)
|
|
Core.randu(dst: grayRnd, low: 0, high: 255)
|
|
Core.randu(dst: grayRnd_32f, low:0, high: 255)
|
|
do {
|
|
try v1.put(row: 0,col: 0, data: [1.0, 3.0, 2.0])
|
|
try v2.put(row: 0,col: 0, data: [2.0, 1.0, 3.0])
|
|
} catch {
|
|
print("Fatal error in start-up")
|
|
}
|
|
}
|
|
|
|
override open func tearDown() {
|
|
// Put teardown code here. This method is called after the invocation of each test method in the class.
|
|
}
|
|
|
|
func assertMatEqual(_ expected:Mat, _ actual:Mat, file: StaticString = #file, line: UInt = #line) throws {
|
|
try compareMats(expected, actual, true, file:file, line:line)
|
|
}
|
|
|
|
func assertMatNotEqual(_ expected:Mat, _ actual:Mat, file: StaticString = #file, line: UInt = #line) throws {
|
|
try compareMats(expected, actual, false, file:file, line:line)
|
|
}
|
|
|
|
func assertMatEqual(_ expected:Mat, _ actual:Mat, _ eps:Double, file: StaticString = #file, line: UInt = #line) throws {
|
|
try compareMats(expected, actual, eps, true, file:file, line:line);
|
|
}
|
|
|
|
func assertMatNotEqual(_ expected:Mat, _ actual:Mat, _ eps:Double, file: StaticString = #file, line: UInt = #line) throws {
|
|
try compareMats(expected, actual, eps, false, file:file, line:line);
|
|
}
|
|
|
|
func assertSizeEquals(_ expected:Size,_ actual: Size, file: StaticString = #file, line: UInt = #line) {
|
|
let msg = "expected:<\(expected)> but was:<\(actual)>"
|
|
XCTAssertEqual(expected.width, actual.width, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.height, actual.height, msg, file:file, line:line)
|
|
}
|
|
|
|
func assertSize2fEquals(_ expected:Size2f,_ actual: Size2f,_ eps: Float, file: StaticString = #file, line: UInt = #line) {
|
|
let msg = "expected:<\(expected)> but was:<\(actual)>"
|
|
XCTAssertEqual(expected.width, actual.width, accuracy:eps, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.height, actual.height, accuracy:eps, msg, file:file, line:line)
|
|
}
|
|
|
|
func assertSize2dEquals(_ expected:Size2d,_ actual: Size2d,_ eps: Double, file: StaticString = #file, line: UInt = #line) {
|
|
let msg = "expected:<\(expected)> but was:<\(actual)>"
|
|
XCTAssertEqual(expected.width, actual.width, accuracy:eps, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.height, actual.height, accuracy:eps, msg, file:file, line:line)
|
|
}
|
|
|
|
func assertPointEquals(_ expected:Point, _ actual: Point, file: StaticString = #file, line: UInt = #line) {
|
|
let msg = "expected:<\(expected)> but was:<\(actual)>"
|
|
XCTAssertEqual(expected.x, actual.x, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.y, actual.y, msg, file:file, line:line)
|
|
}
|
|
|
|
func assertPoint2dEquals(_ expected:Point2d, _ actual: Point2d, _ eps: Double, file: StaticString = #file, line: UInt = #line) {
|
|
let msg = "expected:<\(expected)> but was:<\(actual)>"
|
|
XCTAssertEqual(expected.x, actual.x, accuracy:eps, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.y, actual.y, accuracy:eps, msg, file:file, line:line)
|
|
}
|
|
|
|
func assertPoint2fEquals(_ expected:Point2f, _ actual: Point2f, _ eps: Float, file: StaticString = #file, line: UInt = #line) {
|
|
let msg = "expected:<\(expected)> but was:<\(actual)>"
|
|
XCTAssertEqual(expected.x, actual.x, accuracy:eps, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.y, actual.y, accuracy:eps, msg, file:file, line:line)
|
|
}
|
|
|
|
func assertScalarEqual(_ expected:Scalar, _ actual:Scalar, _ eps: Double, file: StaticString = #file, line: UInt = #line) {
|
|
let msg = "expected:<\(expected)> but was:<\(actual)>"
|
|
XCTAssertEqual(expected.val[0] as! Double, actual.val[0] as! Double, accuracy:eps, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.val[1] as! Double, actual.val[1] as! Double, accuracy:eps, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.val[2] as! Double, actual.val[2] as! Double, accuracy:eps, msg, file:file, line:line)
|
|
XCTAssertEqual(expected.val[3] as! Double, actual.val[3] as! Double, accuracy:eps, msg, file:file, line:line)
|
|
}
|
|
|
|
func assertArrayEquals(_ expected:[Double], _ actual:[Double], _ eps: Double, file: StaticString = #file, line: UInt = #line) {
|
|
XCTAssertEqual(expected.count, actual.count, "Arrays have different sizes.", file:file, line:line)
|
|
|
|
for i in 0..<expected.count {
|
|
XCTAssertEqual(expected[i], actual[i], accuracy:eps, file:file, line:line)
|
|
}
|
|
}
|
|
|
|
func compareMats(_ expected:Mat, _ actual:Mat, _ isEqualityMeasured:Bool, file: StaticString = #file, line: UInt = #line) throws {
|
|
if expected.type() != actual.type() || !dimensionsEqual(expected, actual) {
|
|
throw OpenCVTestError.unsupportedOperationError("Incompatible matrices")
|
|
}
|
|
|
|
if (expected.depth() == CvType.CV_32F || expected.depth() == CvType.CV_64F) {
|
|
if isEqualityMeasured {
|
|
throw OpenCVTestError.unsupportedOperationError("Floating-point Mats must not be checked for exact match. Use assertMatEqual(expected:Mat, actual:Mat, eps:Double) instead.")
|
|
} else {
|
|
throw OpenCVTestError.unsupportedOperationError("Floating-point Mats must not be checked for exact match. Use assertMatNotEqual(expected:Mat, actual:Mat, eps:Double) instead.")
|
|
}
|
|
}
|
|
|
|
let diff = Mat()
|
|
Core.absdiff(src1: expected, src2: actual, dst: diff);
|
|
let reshaped = diff.reshape(channels: 1)
|
|
let mistakes = Core.countNonZero(src: reshaped)
|
|
|
|
if isEqualityMeasured {
|
|
XCTAssertTrue(mistakes == 0, "Mats are different in \(mistakes) points", file:file, line:line)
|
|
} else {
|
|
XCTAssertFalse(mistakes == 0, "Mats are equal", file:file, line:line)
|
|
}
|
|
}
|
|
|
|
func compareMats(_ expected: Mat, _ actual:Mat, _ eps:Double, _ isEqualityMeasured:Bool, file: StaticString = #file, line: UInt = #line) throws {
|
|
if expected.type() != actual.type() || !dimensionsEqual(expected, actual) {
|
|
throw OpenCVTestError.unsupportedOperationError("Incompatible matrices")
|
|
}
|
|
|
|
let diff = Mat()
|
|
Core.absdiff(src1: expected, src2: actual, dst: diff)
|
|
let maxDiff = Core.norm(src1: diff, normType: .NORM_INF)
|
|
|
|
if isEqualityMeasured {
|
|
XCTAssertTrue(maxDiff <= eps, "Max difference between expected and actual Mats is \(maxDiff), that bigger than \(eps)", file:file, line:line)
|
|
} else {
|
|
XCTAssertFalse(maxDiff <= eps, "Max difference between expected and actual Mats is \(maxDiff), that less than \(eps)", file:file, line:line)
|
|
}
|
|
}
|
|
|
|
func dimensionsEqual(_ expected: Mat, _ actual: Mat) -> Bool {
|
|
if expected.dims() != actual.dims() {
|
|
return false
|
|
}
|
|
if expected.dims() > 2 {
|
|
return (0..<expected.dims()).allSatisfy { expected.size($0) == actual.size($0) }
|
|
} else {
|
|
return expected.cols() == actual.cols() && expected.rows() == actual.rows();
|
|
}
|
|
}
|
|
|
|
func getMat(_ type:Int32, vals:[NSNumber]) -> Mat {
|
|
return Mat(rows:OpenCVTestCase.matSize, cols:OpenCVTestCase.matSize, type:type, scalar:Scalar(vals: vals))
|
|
}
|
|
|
|
func makeMask(_ mat:Mat, vals:[Double] = []) -> Mat {
|
|
mat.submat(rowStart: 0, rowEnd: mat.rows(), colStart: 0, colEnd: mat.cols() / 2).setTo(scalar: Scalar(vals: vals as [NSNumber]))
|
|
return mat
|
|
}
|
|
}
|