mirror of
https://github.com/opencv/opencv.git
synced 2024-11-27 20:50:25 +08:00
1745 lines
75 KiB
Swift
1745 lines
75 KiB
Swift
//
|
|
// ImgprocTest.swift
|
|
//
|
|
// Created by Giles Payne on 2020/02/08.
|
|
//
|
|
|
|
import XCTest
|
|
import OpenCV
|
|
|
|
class ImgprocTest: OpenCVTestCase {
|
|
|
|
let anchorPoint = Point(x: 2, y: 2)
|
|
let imgprocSz: Int32 = 2
|
|
let size = Size(width: 3, height: 3)
|
|
|
|
func testAccumulateMatMat() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let dst = getMat(CvType.CV_64F, vals: [0])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulate(src: src, dst: dst)
|
|
Imgproc.accumulate(src: src, dst: dst2)
|
|
|
|
try assertMatEqual(src, dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals: [4]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAccumulateMatMatMat() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let mask = makeMask(getMat(CvType.CV_8U, vals: [1]))
|
|
let dst = getMat(CvType.CV_64F, vals: [0])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulate(src: src, dst: dst, mask: mask)
|
|
Imgproc.accumulate(src: src, dst: dst2, mask: mask)
|
|
|
|
try assertMatEqual(makeMask(getMat(CvType.CV_64F, vals: [2])), dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(makeMask(getMat(CvType.CV_64F, vals: [4]), vals: [2]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAccumulateProductMatMatMat() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let dst = getMat(CvType.CV_64F, vals: [0])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulateProduct(src1: src, src2: src, dst: dst)
|
|
Imgproc.accumulateProduct(src1: src, src2: dst, dst: dst2)
|
|
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals:[4]), dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals:[10]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAccumulateProductMatMatMatMat() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let mask = makeMask(getMat(CvType.CV_8U, vals: [1]))
|
|
let dst = getMat(CvType.CV_64F, vals: [0])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulateProduct(src1: src, src2: src, dst: dst, mask: mask)
|
|
Imgproc.accumulateProduct(src1: src, src2: dst, dst: dst2, mask: mask)
|
|
|
|
try assertMatEqual(makeMask(getMat(CvType.CV_64F, vals: [4])), dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(makeMask(getMat(CvType.CV_64F, vals: [10]), vals:[2]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAccumulateSquareMatMat() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let dst = getMat(CvType.CV_64F, vals: [0])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulateSquare(src: src, dst: dst)
|
|
Imgproc.accumulateSquare(src: src, dst: dst2)
|
|
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals: [4]), dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals: [6]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAccumulateSquareMatMatMat() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let mask = makeMask(getMat(CvType.CV_8U, vals: [1]))
|
|
let dst = getMat(CvType.CV_64F, vals: [0])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulateSquare(src: src, dst: dst, mask: mask)
|
|
Imgproc.accumulateSquare(src: src, dst: dst2, mask: mask)
|
|
|
|
try assertMatEqual(makeMask(getMat(CvType.CV_64F, vals: [4])), dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(makeMask(getMat(CvType.CV_64F, vals: [6]), vals: [2]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAccumulateWeightedMatMatDouble() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let dst = getMat(CvType.CV_64F, vals: [4])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulateWeighted(src: src, dst: dst, alpha: 0.5)
|
|
Imgproc.accumulateWeighted(src: src, dst: dst2, alpha: 2)
|
|
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals: [3]), dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals: [2]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAccumulateWeightedMatMatDoubleMat() throws {
|
|
let src = getMat(CvType.CV_64F, vals: [2])
|
|
let mask = makeMask(getMat(CvType.CV_8U, vals: [1]))
|
|
let dst = getMat(CvType.CV_64F, vals: [4])
|
|
let dst2 = src.clone()
|
|
|
|
Imgproc.accumulateWeighted(src: src, dst: dst, alpha: 0.5, mask: mask)
|
|
Imgproc.accumulateWeighted(src: src, dst: dst2, alpha: 2, mask: mask)
|
|
|
|
try assertMatEqual(makeMask(getMat(CvType.CV_64F, vals: [3]), vals: [4]), dst, OpenCVTestCase.EPS)
|
|
try assertMatEqual(getMat(CvType.CV_64F, vals: [2]), dst2, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testAdaptiveThreshold() {
|
|
let src = makeMask(getMat(CvType.CV_8U, vals: [50]), vals:[20])
|
|
let dst = Mat()
|
|
|
|
Imgproc.adaptiveThreshold(src: src, dst: dst, maxValue: 1, adaptiveMethod: .ADAPTIVE_THRESH_MEAN_C, thresholdType: .THRESH_BINARY, blockSize: 3, C: 0)
|
|
|
|
XCTAssertEqual(src.rows(), Core.countNonZero(src: dst))
|
|
}
|
|
|
|
func testApproxPolyDP() {
|
|
let curve = [Point2f(x: 1, y: 3), Point2f(x: 2, y: 4), Point2f(x: 3, y: 5), Point2f(x: 4, y: 4), Point2f(x: 5, y: 3)]
|
|
|
|
var approxCurve = [Point2f]()
|
|
|
|
Imgproc.approxPolyDP(curve: curve, approxCurve: &approxCurve, epsilon: OpenCVTestCase.EPS, closed: true)
|
|
|
|
let approxCurveGold = [Point2f(x: 1, y: 3), Point2f(x: 3, y: 5), Point2f(x: 5, y: 3)]
|
|
|
|
XCTAssert(approxCurve == approxCurveGold)
|
|
}
|
|
|
|
func testArcLength() {
|
|
let curve = [Point2f(x: 1, y: 3), Point2f(x: 2, y: 4), Point2f(x: 3, y: 5), Point2f(x: 4, y: 4), Point2f(x: 5, y: 3)]
|
|
|
|
let arcLength = Imgproc.arcLength(curve: curve, closed: false)
|
|
|
|
XCTAssertEqual(5.656854249, arcLength, accuracy:0.000001)
|
|
}
|
|
|
|
func testBilateralFilterMatMatIntDoubleDouble() throws {
|
|
Imgproc.bilateralFilter(src: gray255, dst: dst, d: 5, sigmaColor: 10, sigmaSpace: 5)
|
|
|
|
try assertMatEqual(gray255, dst)
|
|
}
|
|
|
|
func testBilateralFilterMatMatIntDoubleDoubleInt() throws {
|
|
Imgproc.bilateralFilter(src: gray255, dst: dst, d: 5, sigmaColor: 10, sigmaSpace: 5, borderType: .BORDER_REFLECT)
|
|
|
|
try assertMatEqual(gray255, dst)
|
|
}
|
|
|
|
func testBlurMatMatSize() throws {
|
|
Imgproc.blur(src: gray0, dst: dst, ksize: size)
|
|
try assertMatEqual(gray0, dst)
|
|
|
|
Imgproc.blur(src: gray255, dst: dst, ksize: size)
|
|
try assertMatEqual(gray255, dst)
|
|
}
|
|
|
|
func testBlurMatMatSizePoint() throws {
|
|
Imgproc.blur(src: gray0, dst: dst, ksize: size, anchor: anchorPoint)
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testBlurMatMatSizePointInt() throws {
|
|
Imgproc.blur(src: gray0, dst: dst, ksize: size, anchor: anchorPoint, borderType: .BORDER_REFLECT)
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testBoundingRect() {
|
|
let points = [Point(x: 0, y: 0), Point(x: 0, y: 4), Point(x: 4, y: 0), Point(x: 4, y: 4)]
|
|
let p1 = Point(x: 1, y: 1)
|
|
let p2 = Point(x: -5, y: -2)
|
|
|
|
let bbox = Imgproc.boundingRect(array: MatOfPoint(array: points))
|
|
|
|
XCTAssert(bbox.contains(p1))
|
|
XCTAssertFalse(bbox.contains(p2))
|
|
}
|
|
|
|
func testBoxFilterMatMatIntSize() throws {
|
|
let size = Size(width: 3, height: 3)
|
|
Imgproc.boxFilter(src: gray0, dst: dst, ddepth: 8, ksize: size)
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testBoxFilterMatMatIntSizePointBoolean() throws {
|
|
Imgproc.boxFilter(src: gray255, dst: dst, ddepth: 8, ksize: size, anchor: anchorPoint, normalize: false)
|
|
try assertMatEqual(gray255, dst)
|
|
}
|
|
|
|
func testBoxFilterMatMatIntSizePointBooleanInt() throws {
|
|
Imgproc.boxFilter(src: gray255, dst: dst, ddepth: 8, ksize: size, anchor: anchorPoint, normalize: false, borderType: .BORDER_REFLECT)
|
|
try assertMatEqual(gray255, dst)
|
|
}
|
|
|
|
func testCalcBackProject() {
|
|
let images = [grayChess]
|
|
let channels:[Int32] = [0]
|
|
let histSize:[Int32] = [10]
|
|
let ranges:[Float] = [0, 256]
|
|
|
|
let hist = Mat()
|
|
Imgproc.calcHist(images: images, channels: channels, mask: Mat(), hist: hist, histSize: histSize, ranges: ranges)
|
|
Core.normalize(src: hist, dst: hist)
|
|
|
|
Imgproc.calcBackProject(images: images, channels: channels, hist: hist, dst: dst, ranges: ranges, scale: 255)
|
|
|
|
XCTAssertEqual(grayChess.size(), dst.size())
|
|
XCTAssertEqual(grayChess.depth(), dst.depth())
|
|
XCTAssertFalse(0 == Core.countNonZero(src: dst))
|
|
}
|
|
|
|
func testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat() throws {
|
|
let images = [gray128]
|
|
let channels:[Int32] = [0]
|
|
let histSize:[Int32] = [10]
|
|
let ranges:[Float] = [0, 256]
|
|
let hist = Mat()
|
|
|
|
Imgproc.calcHist(images: images, channels: channels, mask: Mat(), hist: hist, histSize: histSize, ranges: ranges)
|
|
|
|
truth = Mat(rows: 10, cols: 1, type: CvType.CV_32F, scalar: Scalar.all(0))
|
|
try truth!.put(row: 5, col: 0, data: [100] as [Float])
|
|
try assertMatEqual(truth!, hist, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat2D() throws {
|
|
let images = [gray255, gray128]
|
|
let channels:[Int32] = [0, 1]
|
|
let histSize:[Int32] = [10, 10]
|
|
let ranges:[Float] = [0, 256, 0, 256]
|
|
let hist = Mat()
|
|
|
|
Imgproc.calcHist(images: images, channels: channels, mask: Mat(), hist: hist, histSize: histSize, ranges: ranges)
|
|
|
|
truth = Mat(rows: 10, cols: 10, type: CvType.CV_32F, scalar: Scalar.all(0))
|
|
try truth!.put(row: 9, col: 5, data: [100] as [Float])
|
|
try assertMatEqual(truth!, hist, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloat3D() throws {
|
|
let images = [rgbLena]
|
|
|
|
let hist3D = Mat()
|
|
let histList = [Mat(), Mat(), Mat()]
|
|
|
|
let histSize: [Int32] = [10]
|
|
let ranges: [Float] = [0, 256]
|
|
|
|
for i:Int in 0..<Int(rgbLena.channels()) {
|
|
Imgproc.calcHist(images: images, channels: [Int32(i)], mask: Mat(), hist: histList[i], histSize: histSize, ranges: ranges)
|
|
|
|
XCTAssertEqual(10, histList[i].checkVector(elemChannels: 1))
|
|
}
|
|
|
|
Core.merge(mv: histList, dst: hist3D)
|
|
|
|
XCTAssertEqual(CvType.CV_32FC3, hist3D.type())
|
|
XCTAssertEqual(10, hist3D.checkVector(elemChannels: 3))
|
|
|
|
let truth = Mat(rows: 10, cols: 1, type: CvType.CV_32FC3)
|
|
try truth.put(row: 0, col: 0,
|
|
data: [0, 24870, 0,
|
|
1863, 31926, 1,
|
|
56682, 37677, 2260,
|
|
77278, 44751, 32436,
|
|
69397, 41343, 18526,
|
|
27180, 40407, 18658,
|
|
21101, 15993, 32042,
|
|
8343, 18585, 47786,
|
|
300, 6567, 80988,
|
|
0, 25, 29447] as [Float])
|
|
|
|
try assertMatEqual(truth, hist3D, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCalcHistListOfMatListOfIntegerMatMatListOfIntegerListOfFloatBoolean() throws {
|
|
let images = [gray255, gray128]
|
|
let channels:[Int32] = [0, 1]
|
|
let histSize:[Int32] = [10, 10]
|
|
let ranges:[Float] = [0, 256, 0, 256]
|
|
let hist = Mat()
|
|
|
|
Imgproc.calcHist(images: images, channels: channels, mask: Mat(), hist: hist, histSize: histSize, ranges: ranges, accumulate: true)
|
|
|
|
truth = Mat(rows: 10, cols: 10, type: CvType.CV_32F, scalar: Scalar.all(0))
|
|
try truth!.put(row: 9, col: 5, data: [100] as [Float])
|
|
try assertMatEqual(truth!, hist, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCannyMatMatDoubleDouble() throws {
|
|
Imgproc.Canny(image: gray255, edges: dst, threshold1: 5, threshold2: 10)
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testCannyMatMatDoubleDoubleIntBoolean() throws {
|
|
Imgproc.Canny(image: gray0, edges: dst, threshold1: 5, threshold2: 10, apertureSize: 5, L2gradient: true)
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testCompareHist() throws {
|
|
let H1 = Mat(rows: 3, cols: 1, type: CvType.CV_32F)
|
|
let H2 = Mat(rows: 3, cols: 1, type: CvType.CV_32F)
|
|
try H1.put(row: 0, col: 0, data: [1, 2, 3] as [Float])
|
|
try H2.put(row: 0, col: 0, data: [4, 5, 6] as [Float])
|
|
|
|
let distance = Imgproc.compareHist(H1: H1, H2: H2, method: .HISTCMP_CORREL)
|
|
|
|
XCTAssertEqual(1.0, distance, accuracy: OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testContourAreaMat() throws {
|
|
let contour = Mat(rows: 1, cols: 4, type: CvType.CV_32FC2)
|
|
try contour.put(row: 0, col: 0, data: [0, 0, 10, 0, 10, 10, 5, 4] as [Float])
|
|
|
|
let area = Imgproc.contourArea(contour: contour)
|
|
|
|
XCTAssertEqual(45.0, area, accuracy: OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testContourAreaMatBoolean() throws {
|
|
let contour = Mat(rows: 1, cols: 4, type: CvType.CV_32FC2)
|
|
try contour.put(row: 0, col: 0, data: [0, 0, 10, 0, 10, 10, 5, 4] as [Float])
|
|
|
|
let area = Imgproc.contourArea(contour: contour, oriented: true)
|
|
|
|
XCTAssertEqual(45.0, area, accuracy: OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testConvertMapsMatMatMatMatInt() throws {
|
|
let map1 = Mat(rows: 1, cols: 4, type: CvType.CV_32FC1, scalar: Scalar(1))
|
|
let map2 = Mat(rows: 1, cols: 4, type: CvType.CV_32FC1, scalar: Scalar(2))
|
|
let dstmap1 = Mat(rows: 1, cols: 4, type: CvType.CV_16SC2)
|
|
let dstmap2 = Mat(rows: 1, cols: 4, type: CvType.CV_16UC1)
|
|
|
|
Imgproc.convertMaps(map1: map1, map2: map2, dstmap1: dstmap1, dstmap2: dstmap2, dstmap1type: CvType.CV_16SC2)
|
|
|
|
let truthMap1 = Mat(rows: 1, cols: 4, type: CvType.CV_16SC2)
|
|
try truthMap1.put(row: 0, col: 0, data: [1, 2, 1, 2, 1, 2, 1, 2] as [Int16])
|
|
try assertMatEqual(truthMap1, dstmap1)
|
|
let truthMap2 = Mat(rows: 1, cols: 4, type: CvType.CV_16UC1, scalar: Scalar(0))
|
|
try assertMatEqual(truthMap2, dstmap2)
|
|
}
|
|
|
|
func testConvertMapsMatMatMatMatIntBoolean() throws {
|
|
let map1 = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1, scalar: Scalar(2))
|
|
let map2 = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1, scalar: Scalar(4))
|
|
let dstmap1 = Mat(rows: 1, cols: 3, type: CvType.CV_16SC2)
|
|
let dstmap2 = Mat(rows: 1, cols: 3, type: CvType.CV_16UC1)
|
|
|
|
Imgproc.convertMaps(map1: map1, map2: map2, dstmap1: dstmap1, dstmap2: dstmap2, dstmap1type: CvType.CV_16SC2, nninterpolation: false)
|
|
// TODO_: write better test (last param == true)
|
|
|
|
let truthMap1 = Mat(rows: 1, cols: 3, type: CvType.CV_16SC2)
|
|
try truthMap1.put(row: 0, col: 0, data: [2, 4, 2, 4, 2, 4] as [Int16])
|
|
try assertMatEqual(truthMap1, dstmap1)
|
|
let truthMap2 = Mat(rows: 1, cols: 3, type: CvType.CV_16UC1, scalar: Scalar(0))
|
|
try assertMatEqual(truthMap2, dstmap2)
|
|
}
|
|
|
|
func testConvexHullMatMat() {
|
|
let points = [Point(x: 20, y: 0),
|
|
Point(x: 40, y: 0),
|
|
Point(x: 30, y: 20),
|
|
Point(x: 0, y: 20),
|
|
Point(x: 20, y: 10),
|
|
Point(x: 30, y: 10)]
|
|
|
|
var hull = [Int32]()
|
|
|
|
Imgproc.convexHull(points: points, hull: &hull)
|
|
|
|
XCTAssert([0, 1, 2, 3] == hull)
|
|
}
|
|
|
|
func testConvexHullMatMatBooleanBoolean() {
|
|
let points = [Point(x: 2, y: 0),
|
|
Point(x: 4, y: 0),
|
|
Point(x: 3, y: 2),
|
|
Point(x: 0, y: 2),
|
|
Point(x: 2, y: 1),
|
|
Point(x: 3, y: 1)]
|
|
|
|
var hull = [Int32]()
|
|
|
|
Imgproc.convexHull(points: points, hull: &hull, clockwise: true)
|
|
|
|
XCTAssert([3, 2, 1, 0] == hull)
|
|
}
|
|
|
|
func testConvexityDefects() throws {
|
|
let points = [Point(x: 20, y: 0),
|
|
Point(x: 40, y: 0),
|
|
Point(x: 30, y: 20),
|
|
Point(x: 0, y: 20),
|
|
Point(x: 20, y: 10),
|
|
Point(x: 30, y: 10)]
|
|
|
|
var hull = [Int32]()
|
|
Imgproc.convexHull(points: points, hull: &hull)
|
|
|
|
var convexityDefects = [Int4]()
|
|
Imgproc.convexityDefects(contour: points, convexhull: hull, convexityDefects: &convexityDefects)
|
|
|
|
XCTAssertTrue(Int4(v0: 3, v1: 0, v2: 5, v3: 3620) == convexityDefects[0])
|
|
}
|
|
|
|
func testCornerEigenValsAndVecsMatMatIntInt() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32FC1)
|
|
try src.put(row: 0, col: 0, data: [1, 2] as [Float])
|
|
try src.put(row: 1, col: 0, data: [4, 2] as [Float])
|
|
|
|
let blockSize:Int32 = 3
|
|
let ksize:Int32 = 5
|
|
|
|
// TODO: eigen vals and vectors returned = 0 for most src matrices
|
|
Imgproc.cornerEigenValsAndVecs(src: src, dst: dst, blockSize: blockSize, ksize: ksize)
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32FC(6), scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCornerEigenValsAndVecsMatMatIntIntInt() throws {
|
|
let src = Mat(rows: 4, cols: 4, type: CvType.CV_32FC1, scalar: Scalar(128))
|
|
|
|
let blockSize:Int32 = 3
|
|
let ksize:Int32 = 5
|
|
|
|
truth = Mat(rows: 4, cols: 4, type: CvType.CV_32FC(6), scalar: Scalar(0))
|
|
|
|
Imgproc.cornerEigenValsAndVecs(src: src, dst: dst, blockSize: blockSize, ksize: ksize, borderType: .BORDER_REFLECT)
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCornerHarrisMatMatIntIntDouble() throws {
|
|
truth = Mat(rows: OpenCVTestCase.matSize, cols: OpenCVTestCase.matSize, type: CvType.CV_32FC1, scalar: Scalar(0))
|
|
let blockSize:Int32 = 5
|
|
let ksize:Int32 = 7
|
|
let k = 0.1
|
|
Imgproc.cornerHarris(src: gray128, dst: dst, blockSize: blockSize, ksize: ksize, k: k)
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCornerHarrisMatMatIntIntDoubleInt() throws {
|
|
truth = Mat(rows: OpenCVTestCase.matSize, cols: OpenCVTestCase.matSize, type: CvType.CV_32FC1, scalar: Scalar(0))
|
|
let blockSize:Int32 = 5
|
|
let ksize:Int32 = 7
|
|
let k = 0.1
|
|
Imgproc.cornerHarris(src: gray255, dst: dst, blockSize: blockSize, ksize: ksize, k: k, borderType: .BORDER_REFLECT)
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCornerMinEigenValMatMatInt() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32FC1)
|
|
try src.put(row: 0, col: 0, data: [1, 2] as [Float])
|
|
try src.put(row: 1, col: 0, data: [2, 1] as [Float])
|
|
let blockSize:Int32 = 5
|
|
|
|
Imgproc.cornerMinEigenVal(src: src, dst: dst, blockSize: blockSize)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32FC1, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
|
|
Imgproc.cornerMinEigenVal(src: gray255, dst: dst, blockSize: blockSize)
|
|
|
|
truth = Mat(rows: OpenCVTestCase.matSize, cols: OpenCVTestCase.matSize, type: CvType.CV_32FC1, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCornerMinEigenValMatMatIntInt() throws {
|
|
let src = Mat.eye(rows: 3, cols: 3, type: CvType.CV_32FC1)
|
|
let blockSize:Int32 = 3
|
|
let ksize:Int32 = 5
|
|
|
|
Imgproc.cornerMinEigenVal(src: src, dst: dst, blockSize: blockSize, ksize: ksize)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_32FC1)
|
|
try truth!.put(row: 0, col: 0, data: [1.0 / 18, 1.0 / 36, 1.0 / 18] as [Float])
|
|
try truth!.put(row: 1, col: 0, data: [1.0 / 36, 1.0 / 18, 1.0 / 36] as [Float])
|
|
try truth!.put(row: 2, col: 0, data: [1.0 / 18, 1.0 / 36, 1.0 / 18] as [Float])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCornerMinEigenValMatMatIntIntInt() throws {
|
|
let src = Mat.eye(rows: 3, cols: 3, type: CvType.CV_32FC1)
|
|
let blockSize:Int32 = 3
|
|
let ksize:Int32 = 5
|
|
|
|
Imgproc.cornerMinEigenVal(src: src, dst: dst, blockSize: blockSize, ksize: ksize, borderType: .BORDER_REFLECT)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_32FC1)
|
|
try truth!.put(row: 0, col: 0, data: [0.68055558, 0.92708349, 0.5868057])
|
|
try truth!.put(row: 1, col: 0, data: [0.92708343, 0.92708343, 0.92708343])
|
|
try truth!.put(row: 2, col: 0, data: [0.58680564, 0.92708343, 0.68055564])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testCornerSubPix() {
|
|
let img = Mat(rows: OpenCVTestCase.matSize, cols: OpenCVTestCase.matSize, type: CvType.CV_8U, scalar: Scalar(128))
|
|
let truthPosition = Point(x: img.cols() / 2, y: img.rows() / 2)
|
|
|
|
let r = Rect(point: Point(x: 0, y: 0), point: truthPosition)
|
|
Imgproc.rectangle(img: img, pt1: r.tl(), pt2: r.br(), color: Scalar(0), thickness: Core.FILLED)
|
|
let corners = MatOfPoint2f(array: [Point2f(x: Float(truthPosition.x + 1), y: Float(truthPosition.y + 1))])
|
|
let winSize = Size(width: 2, height: 2)
|
|
let zeroZone = Size(width: -1, height: -1)
|
|
let criteria = TermCriteria(type: TermCriteria.eps, maxCount: 0, epsilon: 0.01)
|
|
|
|
Imgproc.cornerSubPix(image: img, corners: corners, winSize: winSize, zeroZone: zeroZone, criteria: criteria)
|
|
|
|
assertPoint2fEquals(Point2f(x: Float(truthPosition.x), y: Float(truthPosition.y)), corners.toArray()[0], OpenCVTestCase.weakFEPS)
|
|
}
|
|
|
|
func testDilateMatMatMat() throws {
|
|
let kernel = Mat()
|
|
|
|
Imgproc.dilate(src: gray255, dst: dst, kernel: kernel)
|
|
|
|
try assertMatEqual(gray255, dst)
|
|
|
|
Imgproc.dilate(src: gray1, dst: dst, kernel: kernel)
|
|
|
|
try assertMatEqual(gray1, dst)
|
|
}
|
|
|
|
func testDistanceTransformWithLabels() throws {
|
|
let dstLables = getMat(CvType.CV_32SC1, vals: [0])
|
|
let labels = Mat()
|
|
|
|
Imgproc.distanceTransform(src: gray128, dst: dst, labels: labels, distanceType: .DIST_L2, maskSize: .DIST_MASK_3)
|
|
|
|
try assertMatEqual(dstLables, labels)
|
|
try assertMatEqual(getMat(CvType.CV_32FC1, vals: [8192]), dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testDrawContoursMatListOfMatIntScalar() {
|
|
let gray0clone = gray0.clone()
|
|
Imgproc.rectangle(img: gray0clone, pt1: Point(x: 1, y: 2), pt2: Point(x: 7, y: 8), color: Scalar(100))
|
|
var contours = [[Point]]()
|
|
Imgproc.findContours(image: gray0clone, contours: &contours, hierarchy: Mat(), mode: .RETR_EXTERNAL, method: .CHAIN_APPROX_SIMPLE)
|
|
|
|
Imgproc.drawContours(image: gray0clone, contours: contours, contourIdx: -1, color: Scalar(0))
|
|
|
|
XCTAssertEqual(0, Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testDrawContoursMatListOfMatIntScalarInt() {
|
|
let gray0clone = gray0.clone()
|
|
Imgproc.rectangle(img: gray0clone, pt1: Point(x: 1, y: 2), pt2: Point(x: 7, y: 8), color: Scalar(100))
|
|
var contours = [[Point]]()
|
|
Imgproc.findContours(image: gray0clone, contours: &contours, hierarchy: Mat(), mode: .RETR_EXTERNAL, method: .CHAIN_APPROX_SIMPLE)
|
|
|
|
Imgproc.drawContours(image: gray0clone, contours: contours, contourIdx: -1, color: Scalar(0), thickness: Core.FILLED)
|
|
|
|
XCTAssertEqual(0, Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
|
|
func testEqualizeHist() throws {
|
|
Imgproc.equalizeHist(src: gray0, dst: dst)
|
|
try assertMatEqual(gray0, dst)
|
|
|
|
Imgproc.equalizeHist(src: gray255, dst: dst)
|
|
try assertMatEqual(gray255, dst)
|
|
}
|
|
|
|
func testErodeMatMatMat() throws {
|
|
let kernel = Mat()
|
|
|
|
Imgproc.erode(src: gray128, dst: dst, kernel: kernel)
|
|
|
|
try assertMatEqual(gray128, dst)
|
|
}
|
|
|
|
func testErodeMatMatMatPointInt() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_8U)
|
|
try src.put(row: 0, col: 0, data: [15, 9, 10] as [Int8])
|
|
try src.put(row: 1, col: 0, data: [10, 8, 12] as [Int8])
|
|
try src.put(row: 2, col: 0, data: [12, 20, 25] as [Int8])
|
|
let kernel = Mat()
|
|
|
|
Imgproc.erode(src: src, dst: dst, kernel: kernel, anchor: anchorPoint, iterations: 10)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_8U, scalar: Scalar(8))
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testErodeMatMatMatPointIntIntScalar() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_8U)
|
|
try src.put(row: 0, col: 0, data: [15, 9, 10] as [Int8])
|
|
try src.put(row: 1, col: 0, data: [10, 8, 12] as [Int8])
|
|
try src.put(row: 2, col: 0, data: [12, 20, 25] as [Int8])
|
|
let kernel = Mat()
|
|
let sc = Scalar(3, 3)
|
|
|
|
Imgproc.erode(src: src, dst: dst, kernel: kernel, anchor: anchorPoint, iterations: 10, borderType: .BORDER_REFLECT, borderValue: sc)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_8U, scalar: Scalar(8))
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testFilter2DMatMatIntMat() throws {
|
|
let src = Mat.eye(rows: 4, cols: 4, type: CvType.CV_32F)
|
|
let kernel = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(1))
|
|
|
|
Imgproc.filter2D(src: src, dst: dst, ddepth: -1, kernel: kernel)
|
|
|
|
truth = Mat(rows: 4, cols: 4, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [2, 2, 1, 0] as [Float])
|
|
try truth!.put(row: 1, col: 0, data: [2, 2, 1, 0] as [Float])
|
|
try truth!.put(row: 2, col: 0, data: [1, 1, 2, 1] as [Float])
|
|
try truth!.put(row: 3, col: 0, data: [0, 0, 1, 2] as [Float])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testFilter2DMatMatIntMatPointDoubleInt() throws {
|
|
let kernel = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(0))
|
|
let point = Point(x: 0, y: 0)
|
|
|
|
Imgproc.filter2D(src: gray128, dst: dst, ddepth: -1, kernel: kernel, anchor: point, delta: 2, borderType: .BORDER_CONSTANT)
|
|
|
|
try assertMatEqual(gray2, dst)
|
|
}
|
|
|
|
func testFindContoursMatListOfMatMatIntInt() {
|
|
let img = Mat(rows: 50, cols: 50, type: CvType.CV_8UC1, scalar: Scalar(0))
|
|
var contours = [[Point]]()
|
|
let hierarchy = Mat()
|
|
|
|
Imgproc.findContours(image: img, contours: &contours, hierarchy: hierarchy, mode: .RETR_EXTERNAL, method: .CHAIN_APPROX_SIMPLE)
|
|
|
|
// no contours on empty image
|
|
XCTAssertEqual(contours.count, 0)
|
|
XCTAssertEqual(contours.count, hierarchy.total())
|
|
|
|
Imgproc.rectangle(img: img, pt1: Point(x: 10, y: 20), pt2: Point(x: 20, y: 30), color: Scalar(100), thickness: 3, lineType: .LINE_AA, shift: 0)
|
|
Imgproc.rectangle(img: img, pt1: Point(x: 30, y: 35), pt2: Point(x: 40, y: 45), color: Scalar(200))
|
|
|
|
Imgproc.findContours(image: img, contours: &contours, hierarchy: hierarchy, mode: .RETR_EXTERNAL, method: .CHAIN_APPROX_SIMPLE)
|
|
|
|
// two contours of two rectangles
|
|
XCTAssertEqual(contours.count, 2)
|
|
XCTAssertEqual(contours.count, hierarchy.total())
|
|
}
|
|
|
|
func testFindContoursMatListOfMatMatIntIntPoint() throws {
|
|
let img = Mat(rows: 50, cols: 50, type: CvType.CV_8UC1, scalar: Scalar(0))
|
|
let img2 = img.submat(rowStart: 5, rowEnd: 50, colStart: 3, colEnd: 50)
|
|
var contours = [[Point]]()
|
|
var contours2 = [[Point]]()
|
|
let hierarchy = Mat()
|
|
|
|
Imgproc.rectangle(img: img, pt1: Point(x: 10, y: 20), pt2: Point(x: 20, y: 30), color: Scalar(100), thickness: 3, lineType: .LINE_AA, shift: 0)
|
|
Imgproc.rectangle(img: img, pt1: Point(x: 30, y: 35), pt2: Point(x: 40, y: 45), color: Scalar(200))
|
|
|
|
Imgproc.findContours(image: img, contours: &contours, hierarchy: hierarchy, mode: .RETR_EXTERNAL, method: .CHAIN_APPROX_SIMPLE)
|
|
Imgproc.findContours(image: img2, contours: &contours2, hierarchy: hierarchy, mode: .RETR_EXTERNAL, method: .CHAIN_APPROX_SIMPLE, offset: Point(x: 3, y: 5))
|
|
|
|
XCTAssertEqual(contours.count, contours2.count)
|
|
XCTAssert(contours[0] == contours2[0])
|
|
}
|
|
|
|
func testFitEllipse() {
|
|
let points = [Point2f(x: 0, y: 0), Point2f(x: -1, y: 1), Point2f(x: 1, y: 1), Point2f(x: 1, y: -1), Point2f(x: -1, y: -1)]
|
|
let rrect = Imgproc.fitEllipse(points: points)
|
|
|
|
let FIT_ELLIPSE_CENTER_EPS:Float = 0.01
|
|
let FIT_ELLIPSE_SIZE_EPS:Float = 0.4
|
|
|
|
assertPoint2fEquals(Point2f(x: 0, y: 0), rrect.center, FIT_ELLIPSE_CENTER_EPS)
|
|
XCTAssertEqual(Float(2.828), rrect.size.width, accuracy: FIT_ELLIPSE_SIZE_EPS)
|
|
XCTAssertEqual(Float(2.828), rrect.size.height, accuracy: FIT_ELLIPSE_SIZE_EPS)
|
|
}
|
|
|
|
func testFitLine() throws {
|
|
let points = Mat(rows: 1, cols: 4, type: CvType.CV_32FC2)
|
|
try points.put(row: 0, col: 0, data: [0, 0, 2, 3, 3, 4, 5, 8] as [Float])
|
|
|
|
let linePoints = Mat(rows: 4, cols: 1, type: CvType.CV_32FC1)
|
|
try linePoints.put(row: 0, col: 0, data: [0.53198653, 0.84675282, 2.5, 3.75] as [Float])
|
|
|
|
Imgproc.fitLine(points: points, line: dst, distType: .DIST_L12, param: 0, reps: 0.01, aeps: 0.01)
|
|
|
|
try assertMatEqual(linePoints, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testFloodFillMatMatPointScalar() throws {
|
|
let mask = Mat(rows: OpenCVTestCase.matSize + 2, cols: OpenCVTestCase.matSize + 2, type: CvType.CV_8U, scalar: Scalar(0))
|
|
let img = gray0
|
|
Imgproc.circle(img: mask, center: Point(x: OpenCVTestCase.matSize / 2 + 1, y: OpenCVTestCase.matSize / 2 + 1), radius: 3, color: Scalar(2))
|
|
|
|
let retval = Imgproc.floodFill(image: img, mask: mask, seedPoint: Point(x: OpenCVTestCase.matSize / 2, y: OpenCVTestCase.matSize / 2), newVal: Scalar(1))
|
|
|
|
XCTAssertEqual(Core.countNonZero(src: img), retval)
|
|
Imgproc.circle(img: mask, center: Point(x: OpenCVTestCase.matSize / 2 + 1, y: OpenCVTestCase.matSize / 2 + 1), radius: 3, color: Scalar(0))
|
|
XCTAssertEqual(retval + 4 * (OpenCVTestCase.matSize + 1), Core.countNonZero(src: mask))
|
|
try assertMatEqual(mask.submat(rowStart: 1, rowEnd: OpenCVTestCase.matSize + 1, colStart: 1, colEnd: OpenCVTestCase.matSize + 1), img)
|
|
}
|
|
|
|
func testFloodFillMatMatPointScalar_WithoutMask() {
|
|
let img = gray0
|
|
Imgproc.circle(img: img, center: Point(x: OpenCVTestCase.matSize / 2, y: OpenCVTestCase.matSize / 2), radius: 3, color: Scalar(2))
|
|
|
|
// TODO: ideally we should pass null instead of "new Mat()"
|
|
let retval = Imgproc.floodFill(image: img, mask: Mat(), seedPoint: Point(x: OpenCVTestCase.matSize / 2, y: OpenCVTestCase.matSize / 2), newVal: Scalar(1))
|
|
|
|
Imgproc.circle(img: img, center: Point(x: OpenCVTestCase.matSize / 2, y: OpenCVTestCase.matSize / 2), radius: 3, color: Scalar(0))
|
|
XCTAssertEqual(Core.countNonZero(src: img), retval)
|
|
}
|
|
|
|
func testGaussianBlurMatMatSizeDouble() throws {
|
|
Imgproc.GaussianBlur(src: gray0, dst: dst, ksize: size, sigmaX: 1)
|
|
try assertMatEqual(gray0, dst)
|
|
|
|
Imgproc.GaussianBlur(src: gray2, dst: dst, ksize: size, sigmaX: 1)
|
|
try assertMatEqual(gray2, dst)
|
|
}
|
|
|
|
func testGaussianBlurMatMatSizeDoubleDouble() throws {
|
|
Imgproc.GaussianBlur(src: gray2, dst: dst, ksize: size, sigmaX: 0, sigmaY: 0)
|
|
|
|
try assertMatEqual(gray2, dst)
|
|
}
|
|
|
|
func testGaussianBlurMatMatSizeDoubleDoubleInt() throws {
|
|
Imgproc.GaussianBlur(src: gray2, dst: dst, ksize: size, sigmaX: 1, sigmaY: 3, borderType: .BORDER_REFLECT)
|
|
|
|
try assertMatEqual(gray2, dst)
|
|
}
|
|
|
|
func testGetAffineTransform() throws {
|
|
let src = [Point2f(x: 2, y: 3), Point2f(x: 3, y: 1), Point2f(x: 1, y: 4)]
|
|
let dst = [Point2f(x: 3, y: 3), Point2f(x: 7, y: 4), Point2f(x: 5, y: 6)]
|
|
|
|
let transform = Imgproc.getAffineTransform(src: src, dst: dst)
|
|
|
|
let truth = Mat(rows: 2, cols: 3, type: CvType.CV_64FC1)
|
|
|
|
try truth.put(row: 0, col: 0, data: [-8.0, -6.0, 37.0])
|
|
try truth.put(row: 1, col: 0, data: [-7.0, -4.0, 29.0])
|
|
try assertMatEqual(truth, transform, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testGetDerivKernelsMatMatIntIntInt() throws {
|
|
let kx = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
let ky = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
let expKx = Mat(rows: 3, cols: 1, type: CvType.CV_32F)
|
|
let expKy = Mat(rows: 3, cols: 1, type: CvType.CV_32F)
|
|
try kx.put(row: 0, col: 0, data: [1, 1] as [Float])
|
|
try kx.put(row: 1, col: 0, data: [1, 1] as [Float])
|
|
try ky.put(row: 0, col: 0, data: [2, 2] as [Float])
|
|
try ky.put(row: 1, col: 0, data: [2, 2] as [Float])
|
|
try expKx.put(row: 0, col: 0, data: [1, -2, 1] as [Float])
|
|
try expKy.put(row: 0, col: 0, data: [1, -2, 1] as [Float])
|
|
|
|
Imgproc.getDerivKernels(kx: kx, ky: ky, dx: 2, dy: 2, ksize: 3)
|
|
|
|
try assertMatEqual(expKx, kx, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expKy, ky, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testGetDerivKernelsMatMatIntIntIntBooleanInt() throws {
|
|
let kx = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
let ky = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
let expKx = Mat(rows: 3, cols: 1, type: CvType.CV_32F)
|
|
let expKy = Mat(rows: 3, cols: 1, type: CvType.CV_32F)
|
|
try kx.put(row: 0, col: 0, data: [1, 1] as [Float])
|
|
try kx.put(row: 1, col: 0, data: [1, 1] as [Float])
|
|
try ky.put(row: 0, col: 0, data: [2, 2] as [Float])
|
|
try ky.put(row: 1, col: 0, data: [2, 2] as [Float])
|
|
try expKx.put(row: 0, col: 0, data: [1, -2, 1] as [Float])
|
|
try expKy.put(row: 0, col: 0, data: [1, -2, 1] as [Float])
|
|
|
|
Imgproc.getDerivKernels(kx: kx, ky: ky, dx: 2, dy: 2, ksize: 3, normalize: true, ktype: CvType.CV_32F)
|
|
|
|
try assertMatEqual(expKx, kx, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expKy, ky, OpenCVTestCase.EPS)
|
|
// TODO_: write better test
|
|
}
|
|
|
|
func testGetGaussianKernelIntDouble() throws {
|
|
dst = Imgproc.getGaussianKernel(ksize: 1, sigma: 0.5)
|
|
|
|
truth = Mat(rows: 1, cols: 1, type: CvType.CV_64FC1, scalar: Scalar(1))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testGetGaussianKernelIntDoubleInt() throws {
|
|
dst = Imgproc.getGaussianKernel(ksize: 3, sigma: 0.8, ktype: CvType.CV_32F)
|
|
|
|
truth = Mat(rows: 3, cols: 1, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [0.23899426, 0.52201146, 0.23899426] as [Float])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testGetRectSubPixMatSizePointMat() throws {
|
|
let size = Size(width: 3, height: 3)
|
|
let center = Point2f(x: Float(gray255.cols() / 2), y: Float(gray255.rows() / 2))
|
|
|
|
Imgproc.getRectSubPix(image: gray255, patchSize: size, center: center, patch: dst)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_8U, scalar: Scalar(255))
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testGetRectSubPixMatSizePointMatInt() throws {
|
|
let src = Mat(rows: 10, cols: 10, type: CvType.CV_32F, scalar: Scalar(2))
|
|
let patchSize = Size(width: 5, height: 5)
|
|
let center = Point2f(x: Float(src.cols() / 2), y: Float(src.rows() / 2))
|
|
|
|
Imgproc.getRectSubPix(image: src, patchSize: patchSize, center: center, patch: dst)
|
|
|
|
truth = Mat(rows: 5, cols: 5, type: CvType.CV_32F, scalar: Scalar(2))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testGetRotationMatrix2D() throws {
|
|
let center = Point2f(x: 0, y: 0)
|
|
|
|
dst = Imgproc.getRotationMatrix2D(center: center, angle: 0, scale: 1)
|
|
|
|
truth = Mat(rows: 2, cols: 3, type: CvType.CV_64F)
|
|
try truth!.put(row: 0, col: 0, data: [1.0, 0.0, 0.0])
|
|
try truth!.put(row: 1, col: 0, data: [0.0, 1.0, 0.0])
|
|
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testGetStructuringElementIntSize() throws {
|
|
dst = Imgproc.getStructuringElement(shape: .MORPH_RECT, ksize: size)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_8UC1, scalar: Scalar(1))
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testGetStructuringElementIntSizePoint() throws {
|
|
dst = Imgproc.getStructuringElement(shape: .MORPH_CROSS, ksize: size, anchor: anchorPoint)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_8UC1)
|
|
try truth!.put(row: 0, col: 0, data: [0, 0, 1] as [Int8])
|
|
try truth!.put(row: 1, col: 0, data: [0, 0, 1] as [Int8])
|
|
try truth!.put(row: 2, col: 0, data: [1, 1, 1] as [Int8])
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testGoodFeaturesToTrackMatListOfPointIntDoubleDouble() {
|
|
let src = gray0
|
|
Imgproc.rectangle(img: src, pt1: Point(x: 2, y: 2), pt2: Point(x: 8, y: 8), color: Scalar(100), thickness: -1)
|
|
var lp = [Point]()
|
|
|
|
Imgproc.goodFeaturesToTrack(image: src, corners: &lp, maxCorners: 100, qualityLevel: 0.01, minDistance: 3)
|
|
|
|
XCTAssertEqual(4, lp.count)
|
|
}
|
|
|
|
func testGoodFeaturesToTrackMatListOfPointIntDoubleDoubleMatIntBooleanDouble() {
|
|
let src = gray0
|
|
Imgproc.rectangle(img: src, pt1: Point(x: 2, y: 2), pt2: Point(x: 8, y: 8), color: Scalar(100), thickness: -1)
|
|
var lp = [Point]()
|
|
|
|
Imgproc.goodFeaturesToTrack(image: src, corners: &lp, maxCorners: 100, qualityLevel: 0.01, minDistance: 3, mask: gray1, blockSize: 4, gradientSize: 3, useHarrisDetector: true, k: 0)
|
|
|
|
XCTAssertEqual(4, lp.count)
|
|
}
|
|
|
|
func testHoughCirclesMatMatIntDoubleDouble() {
|
|
let sz:Int32 = 512
|
|
let img = Mat(rows: sz, cols: sz, type: CvType.CV_8U, scalar: Scalar(128))
|
|
let circles = Mat()
|
|
|
|
Imgproc.HoughCircles(image: img, circles: circles, method: .HOUGH_GRADIENT, dp: 2.0, minDist: Double(img.rows() / 4))
|
|
|
|
XCTAssertEqual(0, circles.cols())
|
|
}
|
|
|
|
func testHoughCirclesMatMatIntDoubleDouble1() {
|
|
let sz: Int32 = 512
|
|
let img = Mat(rows: sz, cols: sz, type: CvType.CV_8U, scalar: Scalar(128))
|
|
let circles = Mat()
|
|
|
|
let center = Point(x: img.cols() / 2, y: img.rows() / 2)
|
|
let radius = min(img.cols() / 4, img.rows() / 4)
|
|
Imgproc.circle(img: img, center: center, radius: radius, color: colorBlack, thickness: 3)
|
|
|
|
Imgproc.HoughCircles(image: img, circles: circles, method: .HOUGH_GRADIENT, dp: 2.0, minDist: Double(img.rows() / 4))
|
|
|
|
XCTAssertEqual(1, circles.cols())
|
|
}
|
|
|
|
func testHoughLinesMatMatDoubleDoubleInt() {
|
|
let sz:Int32 = 512
|
|
let img = Mat(rows: sz, cols: sz, type: CvType.CV_8U, scalar: Scalar(0))
|
|
let point1 = Point(x: 50, y: 50)
|
|
let point2 = Point(x: img.cols() / 2, y: img.rows() / 2)
|
|
Imgproc.line(img: img, pt1: point1, pt2: point2, color: colorWhite, thickness: 1)
|
|
let lines = Mat()
|
|
|
|
Imgproc.HoughLines(image: img, lines: lines, rho: 1, theta: 3.1415926/180, threshold: 100)
|
|
|
|
XCTAssertEqual(1, lines.cols())
|
|
}
|
|
|
|
func testHoughLinesPMatMatDoubleDoubleInt() {
|
|
let sz:Int32 = 512
|
|
let img = Mat(rows: sz, cols: sz, type: CvType.CV_8U, scalar: Scalar(0))
|
|
let point1 = Point(x: 0, y: 0)
|
|
let point2 = Point(x: sz, y: sz)
|
|
let point3 = Point(x: sz, y: 0)
|
|
let point4 = Point(x: 2*sz/3, y: sz/3)
|
|
Imgproc.line(img: img, pt1: point1, pt2: point2, color: Scalar.all(255), thickness: 1)
|
|
Imgproc.line(img: img, pt1: point3, pt2: point4, color: Scalar.all(255), thickness: 1)
|
|
let lines = Mat()
|
|
|
|
Imgproc.HoughLinesP(image: img, lines: lines, rho: 1, theta: 3.1415926/180, threshold: 100)
|
|
|
|
XCTAssertEqual(2, lines.rows())
|
|
}
|
|
|
|
func testIntegral2MatMatMat() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_32F, scalar: Scalar(3))
|
|
let expSum = Mat(rows: 4, cols: 4, type: CvType.CV_64F)
|
|
let expSqsum = Mat(rows: 4, cols: 4, type: CvType.CV_64F)
|
|
let sum = Mat()
|
|
let sqsum = Mat()
|
|
|
|
try expSum.put(row: 0, col: 0, data: [0.0, 0.0, 0.0, 0.0])
|
|
try expSum.put(row: 1, col: 0, data: [0.0, 3.0, 6.0, 9.0])
|
|
try expSum.put(row: 2, col: 0, data: [0.0, 6.0, 12.0, 18.0])
|
|
try expSum.put(row: 3, col: 0, data: [0.0, 9.0, 18.0, 27.0])
|
|
|
|
try expSqsum.put(row: 0, col: 0, data: [0.0, 0.0, 0.0, 0.0])
|
|
try expSqsum.put(row: 1, col: 0, data: [0.0, 9.0, 18.0, 27.0])
|
|
try expSqsum.put(row: 2, col: 0, data: [0.0, 18.0, 36.0, 54.0])
|
|
try expSqsum.put(row: 3, col: 0, data: [0.0, 27.0, 54.0, 81.0])
|
|
|
|
Imgproc.integral(src: src, sum: sum, sqsum: sqsum)
|
|
|
|
try assertMatEqual(expSum, sum, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expSqsum, sqsum, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testIntegral2MatMatMatInt() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_32F, scalar: Scalar(3))
|
|
let expSum = Mat(rows: 4, cols: 4, type: CvType.CV_64F)
|
|
let expSqsum = Mat(rows: 4, cols: 4, type: CvType.CV_64F)
|
|
let sum = Mat()
|
|
let sqsum = Mat()
|
|
|
|
try expSum.put(row: 0, col: 0, data: [0.0, 0.0, 0.0, 0.0])
|
|
try expSum.put(row: 1, col: 0, data: [0.0, 3.0, 6.0, 9.0])
|
|
try expSum.put(row: 2, col: 0, data: [0.0, 6.0, 12.0, 18.0])
|
|
try expSum.put(row: 3, col: 0, data: [0.0, 9.0, 18.0, 27.0])
|
|
|
|
try expSqsum.put(row: 0, col: 0, data: [0.0, 0.0, 0.0, 0.0])
|
|
try expSqsum.put(row: 1, col: 0, data: [0.0, 9.0, 18.0, 27.0])
|
|
try expSqsum.put(row: 2, col: 0, data: [0.0, 18.0, 36.0, 54.0])
|
|
try expSqsum.put(row: 3, col: 0, data: [0.0, 27.0, 54.0, 81.0])
|
|
|
|
Imgproc.integral(src: src, sum: sum, sqsum: sqsum, sdepth: CvType.CV_64F, sqdepth: CvType.CV_64F)
|
|
|
|
try assertMatEqual(expSum, sum, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expSqsum, sqsum, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testIntegral3MatMatMatMat() throws {
|
|
let src = Mat(rows: 1, cols: 1, type: CvType.CV_32F, scalar: Scalar(1))
|
|
let expSum = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_64F)
|
|
let expSqsum = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_64F)
|
|
let expTilted = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_64F)
|
|
let sum = Mat()
|
|
let sqsum = Mat()
|
|
let tilted = Mat()
|
|
|
|
try expSum.put(row: 0, col: 0, data: [0.0, 0.0])
|
|
try expSum.put(row: 1, col: 0, data: [0.0, 1.0])
|
|
|
|
try expSqsum.put(row: 0, col: 0, data: [0.0, 0.0])
|
|
try expSqsum.put(row: 1, col: 0, data: [0.0, 1.0])
|
|
|
|
try expTilted.put(row: 0, col: 0, data: [0.0, 0.0])
|
|
try expTilted.put(row: 1, col: 0, data: [0.0, 1.0])
|
|
|
|
Imgproc.integral(src: src, sum: sum, sqsum: sqsum, tilted: tilted)
|
|
|
|
try assertMatEqual(expSum, sum, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expSqsum, sqsum, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expTilted, tilted, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testIntegral3MatMatMatMatInt() throws {
|
|
let src = Mat(rows: 1, cols: 1, type: CvType.CV_32F, scalar: Scalar(1))
|
|
let expSum = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_64F)
|
|
let expSqsum = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_64F)
|
|
let expTilted = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_64F)
|
|
let sum = Mat()
|
|
let sqsum = Mat()
|
|
let tilted = Mat()
|
|
|
|
try expSum.put(row: 0, col: 0, data: [0.0, 0.0])
|
|
try expSum.put(row: 1, col: 0, data: [0.0, 1.0])
|
|
|
|
try expSqsum.put(row: 0, col: 0, data: [0.0, 0.0])
|
|
try expSqsum.put(row: 1, col: 0, data: [0.0, 1.0])
|
|
|
|
try expTilted.put(row: 0, col: 0, data: [0.0, 0.0])
|
|
try expTilted.put(row: 1, col: 0, data: [0.0, 1.0])
|
|
|
|
Imgproc.integral(src: src, sum: sum, sqsum: sqsum, tilted: tilted, sdepth: CvType.CV_64F, sqdepth: CvType.CV_64F)
|
|
|
|
try assertMatEqual(expSum, sum, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expSqsum, sqsum, OpenCVTestCase.EPS)
|
|
try assertMatEqual(expTilted, tilted, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testIntegralMatMat() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(2))
|
|
|
|
Imgproc.integral(src: src, sum: dst)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_64F)
|
|
try truth!.put(row: 0, col: 0, data: [0.0, 0.0, 0.0])
|
|
try truth!.put(row: 1, col: 0, data: [0.0, 2.0, 4.0])
|
|
try truth!.put(row: 2, col: 0, data: [0.0, 4.0, 8.0])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testIntegralMatMatInt() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(2))
|
|
|
|
Imgproc.integral(src: src, sum: dst, sdepth: CvType.CV_64F)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_64F)
|
|
try truth!.put(row: 0, col: 0, data: [0.0, 0.0, 0.0])
|
|
try truth!.put(row: 1, col: 0, data: [0.0, 2.0, 4.0])
|
|
try truth!.put(row: 2, col: 0, data: [0.0, 4.0, 8.0])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testInvertAffineTransform() throws {
|
|
let src = Mat(rows: 2, cols: 3, type: CvType.CV_64F, scalar: Scalar(1))
|
|
|
|
Imgproc.invertAffineTransform(M: src, iM: dst)
|
|
|
|
truth = Mat(rows: 2, cols: 3, type: CvType.CV_64F, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testIsContourConvex() {
|
|
let contour1 = [Point(x: 0, y: 0), Point(x: 10, y: 0), Point(x: 10, y: 10), Point(x: 5, y: 4)]
|
|
|
|
XCTAssertFalse(Imgproc.isContourConvex(contour: contour1))
|
|
|
|
let contour2 = [Point(x: 0, y: 0), Point(x: 10, y: 0), Point(x: 10, y: 10), Point(x: 5, y: 6)]
|
|
|
|
XCTAssert(Imgproc.isContourConvex(contour: contour2))
|
|
}
|
|
|
|
func testLaplacianMatMatInt() throws {
|
|
Imgproc.Laplacian(src: gray0, dst: dst, ddepth: CvType.CV_8U)
|
|
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testLaplacianMatMatIntIntDoubleDouble() throws {
|
|
let src = Mat.eye(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
|
|
Imgproc.Laplacian(src: src, dst: dst, ddepth: CvType.CV_32F, ksize: 1, scale: 2, delta: OpenCVTestCase.EPS)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [-7.9990001, 8.0009995])
|
|
try truth!.put(row: 1, col: 0, data: [8.0009995, -7.9990001])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testLaplacianMatMatIntIntDoubleDoubleInt() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_32F, scalar: Scalar(2))
|
|
|
|
Imgproc.Laplacian(src: src, dst: dst, ddepth: CvType.CV_32F, ksize: 1, scale: 2, delta: OpenCVTestCase.EPS, borderType: .BORDER_REFLECT)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_32F, scalar: Scalar(0.00099945068))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testMatchShapes() throws {
|
|
let contour1 = Mat(rows: 1, cols: 4, type: CvType.CV_32FC2)
|
|
let contour2 = Mat(rows: 1, cols: 4, type: CvType.CV_32FC2)
|
|
try contour1.put(row: 0, col: 0, data: [1, 1, 5, 1, 4, 3, 6, 2] as [Float])
|
|
try contour2.put(row: 0, col: 0, data: [1, 1, 6, 1, 4, 1, 2, 5] as [Float])
|
|
|
|
let distance = Imgproc.matchShapes(contour1: contour1, contour2: contour2, method: .CONTOURS_MATCH_I1, parameter: 1)
|
|
|
|
XCTAssertEqual(2.81109697365334, distance, accuracy:OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testMatchTemplate() throws {
|
|
let image = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U)
|
|
let templ = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U)
|
|
try image.put(row: 0, col: 0, data: [1, 2, 3, 4] as [Int8])
|
|
try templ.put(row: 0, col: 0, data: [5, 6, 7, 8] as [Int8])
|
|
|
|
Imgproc.matchTemplate(image: image, templ: templ, result: dst, method: .TM_CCORR)
|
|
|
|
truth = Mat(rows: 1, cols: 1, type: CvType.CV_32F, scalar: Scalar(70))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
|
|
Imgproc.matchTemplate(image: gray255, templ: gray0, result: dst, method: .TM_CCORR)
|
|
|
|
truth = Mat(rows: 1, cols: 1, type: CvType.CV_32F, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testMedianBlur() throws {
|
|
Imgproc.medianBlur(src: gray255, dst: dst, ksize: 5)
|
|
try assertMatEqual(gray255, dst)
|
|
|
|
Imgproc.medianBlur(src: gray2, dst: dst, ksize: 3)
|
|
try assertMatEqual(gray2, dst)
|
|
// TODO_: write better test
|
|
}
|
|
|
|
func testMinAreaRect() {
|
|
let points = [Point2f(x: 1, y: 1), Point2f(x: 5, y: 1), Point2f(x: 4, y: 3), Point2f(x: 6, y: 2)]
|
|
|
|
let rrect = Imgproc.minAreaRect(points: points)
|
|
|
|
XCTAssertEqual(Size2f(width: 5, height: 2), rrect.size)
|
|
XCTAssertEqual(0.0, rrect.angle)
|
|
XCTAssertEqual(Point2f(x: 3.5, y: 2), rrect.center)
|
|
}
|
|
|
|
func testMinEnclosingCircle() {
|
|
let points = [Point2f(x: 0, y: 0), Point2f(x: -100, y: 0), Point2f(x: 0, y: -100), Point2f(x: 100, y: 0), Point2f(x: 0, y: 100)]
|
|
let actualCenter = Point2f()
|
|
var radius:Float = 0
|
|
|
|
Imgproc.minEnclosingCircle(points: points, center: actualCenter, radius: &radius)
|
|
|
|
XCTAssertEqual(Point2f(x: 0, y: 0), actualCenter)
|
|
XCTAssertEqual(100.0, radius, accuracy: 1.0)
|
|
}
|
|
|
|
func testMorphologyExMatMatIntMat() throws {
|
|
Imgproc.morphologyEx(src: gray255, dst: dst, op: MorphTypes.MORPH_GRADIENT, kernel: gray0)
|
|
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testMorphologyExMatMatIntMatPointInt() throws {
|
|
let src = Mat.eye(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U)
|
|
|
|
let kernel = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U, scalar: Scalar(0))
|
|
let point = Point(x: 0, y: 0)
|
|
|
|
Imgproc.morphologyEx(src: src, dst: dst, op: MorphTypes.MORPH_CLOSE, kernel: kernel, anchor: point, iterations: 10)
|
|
|
|
truth = Mat.eye(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U)
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
|
|
func testMorphologyExMatMatIntMatPointIntIntScalar() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U)
|
|
try src.put(row: 0, col: 0, data: [2, 1] as [Int8])
|
|
try src.put(row: 1, col: 0, data: [2, 1] as [Int8])
|
|
|
|
let kernel = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U, scalar: Scalar(1))
|
|
let point = Point(x: 1, y: 1)
|
|
let sc = Scalar(3, 3)
|
|
|
|
Imgproc.morphologyEx(src: src, dst: dst, op: MorphTypes.MORPH_TOPHAT, kernel: kernel, anchor: point, iterations: 10, borderType: .BORDER_REFLECT, borderValue: sc)
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8U)
|
|
try truth!.put(row: 0, col: 0, data: [1, 0] as [Int8])
|
|
try truth!.put(row: 1, col: 0, data: [1, 0] as [Int8])
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testPointPolygonTest() {
|
|
let contour = [Point2f(x: 0, y: 0), Point2f(x: 1, y: 3), Point2f(x: 3, y: 4), Point2f(x: 4, y: 3), Point2f(x: 2, y: 1)]
|
|
let sign1 = Imgproc.pointPolygonTest(contour: contour, pt: Point2f(x: 2, y: 2), measureDist: false)
|
|
XCTAssertEqual(1.0, sign1)
|
|
|
|
let sign2 = Imgproc.pointPolygonTest(contour: contour, pt: Point2f(x: 4, y: 4), measureDist: true)
|
|
XCTAssertEqual(-sqrt(0.5), sign2)
|
|
}
|
|
|
|
func testPreCornerDetectMatMatInt() throws {
|
|
let src = Mat(rows: 4, cols: 4, type: CvType.CV_32F, scalar: Scalar(1))
|
|
let ksize:Int32 = 3
|
|
|
|
Imgproc.preCornerDetect(src: src, dst: dst, ksize: ksize)
|
|
|
|
truth = Mat(rows: 4, cols: 4, type: CvType.CV_32F, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testPreCornerDetectMatMatIntInt() throws {
|
|
let src = Mat(rows: 4, cols: 4, type: CvType.CV_32F, scalar: Scalar(1))
|
|
let ksize:Int32 = 3
|
|
|
|
Imgproc.preCornerDetect(src: src, dst: dst, ksize: ksize, borderType: .BORDER_REFLECT)
|
|
|
|
truth = Mat(rows: 4, cols: 4, type: CvType.CV_32F, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testPyrDownMatMat() throws {
|
|
let src = Mat(rows: 4, cols: 4, type: CvType.CV_32F)
|
|
try src.put(row: 0, col: 0, data: [2, 1, 4, 2] as [Float])
|
|
try src.put(row: 1, col: 0, data: [3, 2, 6, 8] as [Float])
|
|
try src.put(row: 2, col: 0, data: [4, 6, 8, 10] as [Float])
|
|
try src.put(row: 3, col: 0, data: [12, 32, 6, 18] as [Float])
|
|
|
|
Imgproc.pyrDown(src: src, dst: dst)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [2.78125, 4.609375])
|
|
try truth!.put(row: 1, col: 0, data: [8.546875, 8.8515625])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testPyrDownMatMatSize() throws {
|
|
let src = Mat(rows: 4, cols: 4, type: CvType.CV_32F)
|
|
try src.put(row: 0, col: 0, data: [2, 1, 4, 2] as [Float])
|
|
try src.put(row: 1, col: 0, data: [3, 2, 6, 8] as [Float])
|
|
try src.put(row: 2, col: 0, data: [4, 6, 8, 10] as [Float])
|
|
try src.put(row: 3, col: 0, data: [12, 32, 6, 18] as [Float])
|
|
let dstSize = Size(width: 2, height: 2)
|
|
|
|
Imgproc.pyrDown(src: src, dst: dst, dstsize: dstSize)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [2.78125, 4.609375])
|
|
try truth!.put(row: 1, col: 0, data: [8.546875, 8.8515625])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testPyrMeanShiftFilteringMatMatDoubleDouble() throws {
|
|
let src = Mat(rows: OpenCVTestCase.matSize, cols: OpenCVTestCase.matSize, type: CvType.CV_8UC3, scalar: Scalar(0))
|
|
|
|
Imgproc.pyrMeanShiftFiltering(src: src, dst: dst, sp: 10, sr: 50)
|
|
|
|
try assertMatEqual(src, dst)
|
|
}
|
|
|
|
func testPyrUpMatMat() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
try src.put(row: 0, col: 0, data: [2, 1] as [Float])
|
|
try src.put(row: 1, col: 0, data: [3, 2] as [Float])
|
|
|
|
Imgproc.pyrUp(src: src, dst: dst)
|
|
|
|
truth = Mat(rows: 4, cols: 4, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [2, 1.75, 1.375, 1.25])
|
|
try truth!.put(row: 1, col: 0, data: [2.25, 2, 1.625, 1.5])
|
|
try truth!.put(row: 2, col: 0, data: [2.625, 2.375, 2, 1.875])
|
|
try truth!.put(row: 3, col: 0, data: [2.75, 2.5, 2.125, 2])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testRemapMatMatMatMatInt() throws {
|
|
// this test does something weird
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(2))
|
|
let map1 = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
let map2 = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
|
|
try map1.put(row: 0, col: 0, data: [3, 6, 5] as [Float])
|
|
try map2.put(row: 0, col: 0, data: [4, 8, 12] as [Float])
|
|
|
|
Imgproc.remap(src: src, dst: dst, map1: map1, map2: map2, interpolation: InterpolationFlags.INTER_LINEAR.rawValue)
|
|
|
|
truth = Mat(rows: 1, cols: 3, type: CvType.CV_32F, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testRemapMatMatMatMatIntIntScalar() throws {
|
|
// this test does something weird
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(2))
|
|
let map1 = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
let map2 = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
|
|
let sc = Scalar(0)
|
|
|
|
try map1.put(row: 0, col: 0, data: [3, 6, 5, 0] as [Float])
|
|
try map2.put(row: 0, col: 0, data: [4, 8, 12] as [Float])
|
|
|
|
truth = Mat(rows: 1, cols: 3, type: CvType.CV_32F, scalar: Scalar(2))
|
|
|
|
Imgproc.remap(src: src, dst: dst, map1: map1, map2: map2, interpolation: InterpolationFlags.INTER_LINEAR.rawValue, borderMode: .BORDER_REFLECT, borderValue: sc)
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testResizeMatMatSize() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_8UC1, scalar: Scalar(1))
|
|
let dsize = Size(width: 1, height: 1)
|
|
|
|
Imgproc.resize(src: src, dst: dst, dsize: dsize, fx: 0, fy: 0, interpolation: InterpolationFlags.INTER_LINEAR_EXACT.rawValue)
|
|
|
|
truth = Mat(rows: 1, cols: 1, type: CvType.CV_8UC1, scalar: Scalar(1))
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testResizeMatMatSizeDoubleDoubleInt() throws {
|
|
Imgproc.resize(src: gray255, dst: dst, dsize: Size(width: 2, height: 2), fx: 0, fy: 0, interpolation: InterpolationFlags.INTER_AREA.rawValue)
|
|
|
|
truth = Mat(rows: 2, cols: 2, type: CvType.CV_8UC1, scalar: Scalar(255))
|
|
try assertMatEqual(truth!, dst)
|
|
}
|
|
|
|
func testScharrMatMatIntIntInt() throws {
|
|
let src = Mat.eye(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
|
|
Imgproc.Scharr(src: src, dst: dst, ddepth: CvType.CV_32F, dx: 1, dy: 0)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(0))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testScharrMatMatIntIntIntDoubleDouble() throws {
|
|
let src = Mat.eye(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F)
|
|
|
|
Imgproc.Scharr(src: src, dst: dst, ddepth: CvType.CV_32F, dx: 1, dy: 0, scale: 1.5, delta: 0.001)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(0.001))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testScharrMatMatIntIntIntDoubleDoubleInt() throws {
|
|
let src = Mat.eye(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
|
|
Imgproc.Scharr(src: src, dst: dst, ddepth: CvType.CV_32F, dx: 1, dy: 0, scale: 1.5, delta: 0, borderType: .BORDER_REFLECT)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [-15, -19.5, -4.5])
|
|
try truth!.put(row: 1, col: 0, data: [10.5, 0, -10.5])
|
|
try truth!.put(row: 2, col: 0, data: [4.5, 19.5, 15])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testSepFilter2DMatMatIntMatMat() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(2))
|
|
let kernelX = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
let kernelY = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
try kernelX.put(row: 0, col: 0, data: [4, 3, 7] as [Float])
|
|
try kernelY.put(row: 0, col: 0, data: [9, 4, 2] as [Float])
|
|
|
|
Imgproc.sepFilter2D(src: src, dst: dst, ddepth: CvType.CV_32F, kernelX: kernelX, kernelY: kernelY)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(420))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testSepFilter2DMatMatIntMatMatPointDouble() throws {
|
|
let src = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32FC1, scalar: Scalar(2))
|
|
let kernelX = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
try kernelX.put(row: 0, col: 0, data: [2, 2, 2] as [Float])
|
|
let kernelY = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
try kernelY.put(row: 0, col: 0, data: [1, 1, 1] as [Float])
|
|
|
|
Imgproc.sepFilter2D(src: src, dst: dst, ddepth: CvType.CV_32F, kernelX: kernelX, kernelY: kernelY, anchor: anchorPoint, delta: OpenCVTestCase.weakEPS)
|
|
|
|
truth = Mat(rows: imgprocSz, cols: imgprocSz, type: CvType.CV_32F, scalar: Scalar(36 + OpenCVTestCase.weakEPS))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testSepFilter2DMatMatIntMatMatPointDoubleInt() throws {
|
|
let kernelX = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
try kernelX.put(row: 0, col: 0, data: [2, 2, 2] as [Float])
|
|
|
|
let kernelY = Mat(rows: 1, cols: 3, type: CvType.CV_32FC1)
|
|
try kernelY.put(row: 0, col: 0, data: [1, 1, 1] as [Float])
|
|
|
|
Imgproc.sepFilter2D(src: gray0, dst: dst, ddepth: CvType.CV_32F, kernelX: kernelX, kernelY: kernelY, anchor: anchorPoint, delta: OpenCVTestCase.weakEPS, borderType: .BORDER_REFLECT)
|
|
|
|
truth = Mat(rows: 10, cols: 10, type: CvType.CV_32F, scalar: Scalar(OpenCVTestCase.weakEPS))
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testSobelMatMatIntIntInt() throws {
|
|
Imgproc.Sobel(src: gray255, dst: dst, ddepth: CvType.CV_8U, dx: 1, dy: 0)
|
|
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testSobelMatMatIntIntIntIntDoubleDouble() throws {
|
|
Imgproc.Sobel(src: gray255, dst: dst, ddepth: CvType.CV_8U, dx: 1, dy: 0, ksize: 3, scale: 2, delta: 0.001)
|
|
try assertMatEqual(gray0, dst)
|
|
}
|
|
|
|
func testSobelMatMatIntIntIntIntDoubleDoubleInt() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try src.put(row: 0, col: 0, data: [2, 0, 1] as [Float])
|
|
try src.put(row: 1, col: 0, data: [6, 4, 3] as [Float])
|
|
try src.put(row: 2, col: 0, data: [1, 0, 2] as [Float])
|
|
|
|
Imgproc.Sobel(src: src, dst: dst, ddepth: CvType.CV_32F, dx: 1, dy: 0, ksize: 3, scale: 2, delta: 0, borderType: .BORDER_REPLICATE)
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [-16, -12, 4] as [Float])
|
|
try truth!.put(row: 1, col: 0, data: [-14, -12, 2] as [Float])
|
|
try truth!.put(row: 2, col: 0, data: [-10, 0, 10] as [Float])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testThreshold() throws {
|
|
Imgproc.threshold(src: makeMask(gray0.clone(), vals: [10]), dst: dst, thresh: 5, maxval: 255, type: .THRESH_TRUNC)
|
|
try assertMatEqual(makeMask(gray0.clone(), vals: [5]), dst)
|
|
|
|
Imgproc.threshold(src: makeMask(gray2.clone(), vals: [10]), dst: dst, thresh: 1, maxval: 255, type: .THRESH_BINARY)
|
|
try assertMatEqual(gray255, dst)
|
|
|
|
Imgproc.threshold(src: makeMask(gray2.clone(), vals: [10]), dst: dst, thresh: 3, maxval: 255, type: .THRESH_BINARY_INV)
|
|
try assertMatEqual(makeMask(gray255.clone(), vals: [0]), dst)
|
|
}
|
|
|
|
func testWarpAffineMatMatMatSize() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try src.put(row: 0, col: 0, data: [2, 0, 1] as [Float])
|
|
try src.put(row: 1, col: 0, data: [6, 4, 3] as [Float])
|
|
try src.put(row: 2, col: 0, data: [1, 0, 2] as [Float])
|
|
let M = Mat(rows: 2, cols: 3, type: CvType.CV_32F)
|
|
try M.put(row: 0, col: 0, data: [1, 0, 1] as [Float])
|
|
try M.put(row: 1, col: 0, data: [0, 1, 1] as [Float])
|
|
|
|
Imgproc.warpAffine(src: src, dst: dst, M: M, dsize: Size(width: 3, height: 3))
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [0, 0, 0] as [Float])
|
|
try truth!.put(row: 1, col: 0, data: [0, 2, 0] as [Float])
|
|
try truth!.put(row: 2, col: 0, data: [0, 6, 4] as [Float])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testWarpAffineMatMatMatSizeInt() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try src.put(row: 0, col: 0, data: [2, 4, 1] as [Float])
|
|
try src.put(row: 1, col: 0, data: [6, 4, 3] as [Float])
|
|
try src.put(row: 2, col: 0, data: [0, 2, 2] as [Float])
|
|
let M = Mat(rows: 2, cols: 3, type: CvType.CV_32F)
|
|
try M.put(row: 0, col: 0, data: [1, 0, 0] as [Float])
|
|
try M.put(row: 1, col: 0, data: [0, 0, 1] as [Float])
|
|
|
|
Imgproc.warpAffine(src: src, dst: dst, M: M, dsize: Size(width: 2, height: 2), flags: InterpolationFlags.WARP_INVERSE_MAP.rawValue)
|
|
|
|
truth = Mat(rows: 2, cols: 2, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [6, 4] as [Float])
|
|
try truth!.put(row: 1, col: 0, data: [6, 4] as [Float])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testWarpPerspectiveMatMatMatSize() throws {
|
|
let src = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try src.put(row: 0, col: 0, data: [2, 4, 1] as [Float])
|
|
try src.put(row: 1, col: 0, data: [0, 4, 5] as [Float])
|
|
try src.put(row: 2, col: 0, data: [1, 2, 2] as [Float])
|
|
let M = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try M.put(row: 0, col: 0, data: [1, 0, 1] as [Float])
|
|
try M.put(row: 1, col: 0, data: [0, 1, 1] as [Float])
|
|
try M.put(row: 2, col: 0, data: [0, 0, 1] as [Float])
|
|
|
|
Imgproc.warpPerspective(src: src, dst: dst, M: M, dsize: Size(width: 3, height: 3))
|
|
|
|
truth = Mat(rows: 3, cols: 3, type: CvType.CV_32F)
|
|
try truth!.put(row: 0, col: 0, data: [0, 0, 0] as [Float])
|
|
try truth!.put(row: 1, col: 0, data: [0, 2, 4] as [Float])
|
|
try truth!.put(row: 2, col: 0, data: [0, 0, 4] as [Float])
|
|
try assertMatEqual(truth!, dst, OpenCVTestCase.EPS)
|
|
}
|
|
|
|
func testWatershed() throws {
|
|
let image = Mat.eye(rows: 4, cols: 4, type: CvType.CV_8UC(3))
|
|
let markers = Mat(rows: 4, cols: 4, type: CvType.CV_32SC1, scalar: Scalar(0))
|
|
|
|
Imgproc.watershed(image: image, markers: markers)
|
|
|
|
truth = Mat(rows: 4, cols: 4, type: CvType.CV_32SC1)
|
|
try truth!.put(row: 0, col: 0, data: [-1, -1, -1, -1] as [Int32])
|
|
try truth!.put(row: 1, col: 0, data: [-1, 0, 0, -1] as [Int32])
|
|
try truth!.put(row: 2, col: 0, data: [-1, 0, 0, -1] as [Int32])
|
|
try truth!.put(row: 3, col: 0, data: [-1, -1, -1, -1] as [Int32])
|
|
try assertMatEqual(truth!, markers)
|
|
}
|
|
|
|
func testGetTextSize() {
|
|
let text = "iOS all the way"
|
|
let fontScale:Int32 = 2
|
|
let thickness:Int32 = 3
|
|
var baseLine:Int32 = 0
|
|
|
|
Imgproc.getTextSize(text: text, fontFace: .FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale: Double(fontScale), thickness: thickness, baseLine: &baseLine)
|
|
let res = Imgproc.getTextSize(text: text, fontFace: .FONT_HERSHEY_SCRIPT_SIMPLEX, fontScale: Double(fontScale), thickness: thickness, baseLine: &baseLine)
|
|
|
|
XCTAssertEqual(431, res.width)
|
|
XCTAssertEqual(44, res.height)
|
|
XCTAssertEqual(20, baseLine)
|
|
}
|
|
|
|
func testCircleMatPointIntScalar() {
|
|
let gray0clone = gray0.clone()
|
|
let center = Point(x: gray0clone.cols() / 2, y: gray0clone.rows() / 2)
|
|
let radius = min(gray0clone.cols() / 4, gray0clone.rows() / 4)
|
|
let color = Scalar(128)
|
|
|
|
Imgproc.circle(img: gray0clone, center: center, radius: radius, color: color)
|
|
|
|
XCTAssert(0 != Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testCircleMatPointIntScalarInt() {
|
|
let gray0clone = gray0.clone()
|
|
let center = Point(x: gray0clone.cols() / 2, y: gray0clone.rows() / 2)
|
|
let radius = min(gray0clone.cols() / 4, gray0clone.rows() / 4)
|
|
let color = Scalar(128)
|
|
|
|
Imgproc.circle(img: gray0clone, center: center, radius: radius, color: color, thickness: Core.FILLED)
|
|
|
|
XCTAssert(0 != Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testCircleMatPointIntScalarIntIntInt() {
|
|
let gray0clone = gray0.clone()
|
|
let center = Point(x: gray0clone.cols() / 2, y: gray0clone.rows() / 2)
|
|
let center2 = Point(x: gray0clone.cols(), y: gray0clone.rows())
|
|
let radius = min(gray0clone.cols() / 4, gray0clone.rows() / 4)
|
|
let color128 = Scalar(128)
|
|
let color0 = Scalar(0)
|
|
|
|
Imgproc.circle(img: gray0clone, center: center2, radius: radius * 2, color: color128, thickness: 2, lineType: .LINE_4, shift: 1)
|
|
XCTAssertFalse(0 == Core.countNonZero(src: gray0clone))
|
|
|
|
Imgproc.circle(img: gray0clone, center: center, radius: radius, color: color0, thickness: 2, lineType: .LINE_4, shift: 0)
|
|
|
|
XCTAssert(0 == Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testClipLine() {
|
|
let r = Rect(x: 10, y: 10, width: 10, height: 10)
|
|
var pt1 = Point(x: 5, y: 15)
|
|
var pt2 = Point(x: 25, y: 15)
|
|
|
|
XCTAssert(Imgproc.clipLine(imgRect: r, pt1: pt1, pt2: pt2))
|
|
|
|
var pt1Clipped = Point(x: 10, y: 15)
|
|
var pt2Clipped = Point(x: 19, y: 15)
|
|
XCTAssertEqual(pt1Clipped, pt1)
|
|
XCTAssertEqual(pt2Clipped, pt2)
|
|
|
|
pt1 = Point(x: 5, y: 5)
|
|
pt2 = Point(x: 25, y: 5)
|
|
pt1Clipped = Point(x: 5, y: 5)
|
|
pt2Clipped = Point(x: 25, y: 5)
|
|
|
|
XCTAssertFalse(Imgproc.clipLine(imgRect: r, pt1: pt1, pt2: pt2))
|
|
|
|
XCTAssertEqual(pt1Clipped, pt1)
|
|
XCTAssertEqual(pt2Clipped, pt2)
|
|
}
|
|
|
|
func testEllipse2Poly() {
|
|
let center = Point(x: 4, y: 4)
|
|
let axes = Size(width: 2, height: 2)
|
|
let angle:Int32 = 30
|
|
let arcStart:Int32 = 30
|
|
let arcEnd:Int32 = 60
|
|
let delta:Int32 = 2
|
|
var pts = [Point]()
|
|
|
|
Imgproc.ellipse2Poly(center: center, axes: axes, angle: angle, arcStart: arcStart, arcEnd: arcEnd, delta: delta, pts: &pts)
|
|
|
|
let truth = [Point(x: 5, y: 6), Point(x: 4, y: 6)]
|
|
XCTAssert(truth == pts)
|
|
}
|
|
|
|
func testEllipseMatPointSizeDoubleDoubleDoubleScalar() {
|
|
let gray0clone = gray0.clone()
|
|
let center = Point(x: gray0clone.cols() / 2, y: gray0clone.rows() / 2)
|
|
let axes = Size(width: 2, height: 2)
|
|
let angle = 30.0, startAngle = 60.0, endAngle = 90.0
|
|
|
|
Imgproc.ellipse(img: gray0clone, center: center, axes: axes, angle: angle, startAngle: startAngle, endAngle: endAngle, color: colorWhite)
|
|
|
|
XCTAssert(0 != Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testEllipseMatPointSizeDoubleDoubleDoubleScalarInt() {
|
|
let gray0clone = gray0.clone()
|
|
let center = Point(x: gray0clone.cols() / 2, y: gray0clone.rows() / 2)
|
|
let axes = Size(width: 2, height: 2)
|
|
let angle = 30.0, startAngle = 60.0, endAngle = 90.0
|
|
|
|
Imgproc.ellipse(img: gray0clone, center: center, axes: axes, angle: angle, startAngle: startAngle, endAngle: endAngle, color: colorWhite, thickness: Core.FILLED)
|
|
|
|
XCTAssert(0 != Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testEllipseMatPointSizeDoubleDoubleDoubleScalarIntIntInt() {
|
|
let gray0clone = gray0.clone()
|
|
let center = Point(x: gray0clone.cols() / 2, y: gray0clone.rows() / 2)
|
|
let axes = Size(width: 2, height: 2)
|
|
let center2 = Point(x: gray0clone.cols(), y: gray0clone.rows())
|
|
let axes2 = Size(width: 4, height: 4)
|
|
let angle = 30.0, startAngle = 0.0, endAngle = 30.0
|
|
|
|
Imgproc.ellipse(img: gray0clone, center: center, axes: axes, angle: angle, startAngle: startAngle, endAngle: endAngle, color: colorWhite, thickness: Core.FILLED, lineType: .LINE_4, shift: 0)
|
|
|
|
XCTAssert(0 != Core.countNonZero(src: gray0clone))
|
|
|
|
Imgproc.ellipse(img: gray0clone, center: center2, axes: axes2, angle: angle, startAngle: startAngle, endAngle: endAngle, color: colorBlack, thickness: Core.FILLED, lineType: .LINE_4, shift: 1)
|
|
|
|
XCTAssertEqual(0, Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testEllipseMatRotatedRectScalar() throws {
|
|
let matSize:Int32 = 10
|
|
let gray0 = Mat.zeros(matSize, cols: matSize, type: CvType.CV_8U)
|
|
let center = Point2f(x: Float(matSize / 2), y: Float(matSize / 2))
|
|
let size = Size2f(width: Float(matSize / 4), height: Float(matSize / 2))
|
|
let box = RotatedRect(center: center, size: size, angle: 45)
|
|
|
|
Imgproc.ellipse(img: gray0, box: box, color: Scalar(1))
|
|
|
|
let truth = Mat(rows: matSize, cols: matSize, type: CvType.CV_8U)
|
|
try truth.put(row: 0, col: 0, data: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
|
|
0, 0, 0, 0, 1, 1, 0, 1, 0, 0,
|
|
0, 0, 0, 0, 1, 0, 1, 0, 0, 0,
|
|
0, 0, 0, 1, 0, 1, 1, 0, 0, 0,
|
|
0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0] as [Int8])
|
|
|
|
try assertMatEqual(truth, gray0)
|
|
}
|
|
|
|
func testEllipseMatRotatedRectScalarInt() {
|
|
let gray0clone = gray0.clone()
|
|
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))
|
|
let box = RotatedRect(center: center, size: size, angle: 45)
|
|
|
|
Imgproc.ellipse(img: gray0clone, box: box, color: Scalar(1), thickness: Core.FILLED)
|
|
Imgproc.ellipse(img: gray0clone, box: box, color: Scalar(0))
|
|
|
|
XCTAssert(0 < Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testEllipseMatRotatedRectScalarIntInt() {
|
|
let gray0clone = gray0.clone()
|
|
let center = Point2f(x: Float(OpenCVTestCase.matSize / 2), y: Float(OpenCVTestCase.matSize / 2))
|
|
let size = Size2f(width: 2, height: Float(OpenCVTestCase.matSize * 2 / 3))
|
|
let box = RotatedRect(center: center, size: size, angle: 20)
|
|
|
|
Imgproc.ellipse(img: gray0clone, box: box, color: Scalar(9), thickness: 1, lineType: .LINE_AA)
|
|
Imgproc.ellipse(img: gray0clone, box: box, color: Scalar(0), thickness: 1, lineType: .LINE_4)
|
|
|
|
XCTAssert(0 < Core.countNonZero(src: gray0clone))
|
|
}
|
|
|
|
func testPolylinesMatListOfListOfPointBooleanScalar() {
|
|
let img = gray0.clone()
|
|
let polyline = [[Point(x: 1, y: 1), Point(x: 7, y: 1), Point(x: 7, y: 6), Point(x: 1, y: 6)]]
|
|
|
|
Imgproc.polylines(img: img, pts: polyline, isClosed: true, color: Scalar(100))
|
|
|
|
XCTAssertEqual(22, Core.countNonZero(src: img))
|
|
|
|
Imgproc.polylines(img: img, pts: polyline, isClosed: false, color: Scalar(0))
|
|
|
|
XCTAssertEqual(4, Core.countNonZero(src: img))
|
|
}
|
|
|
|
func testPolylinesMatListOfListOfPointBooleanScalarInt() {
|
|
let img = gray0.clone()
|
|
let polyline = [[Point(x: 1, y: 1), Point(x: 7, y: 1), Point(x: 7, y: 6), Point(x: 1, y: 6)]]
|
|
|
|
Imgproc.polylines(img: img, pts: polyline, isClosed: true, color: Scalar(100), thickness: 2)
|
|
|
|
XCTAssertEqual(62, Core.countNonZero(src: img))
|
|
}
|
|
|
|
func testPolylinesMatListOfListOfPointBooleanScalarIntIntInt() {
|
|
let img = gray0.clone()
|
|
let polyline1 = [[Point(x: 1, y: 1), Point(x: 7, y: 1), Point(x: 7, y: 6), Point(x: 1, y: 6)]]
|
|
let polyline2 = [[Point(x: 2, y: 2), Point(x: 14, y: 2), Point(x: 14, y: 12), Point(x: 2, y: 12)]]
|
|
|
|
Imgproc.polylines(img: img, pts: polyline1, isClosed: true, color: Scalar(100), thickness: 2, lineType: .LINE_8, shift: 0)
|
|
|
|
XCTAssert(Core.countNonZero(src: img) > 0)
|
|
|
|
Imgproc.polylines(img: img, pts: polyline2, isClosed: true, color: Scalar(0), thickness: 2, lineType: .LINE_8, shift: 1)
|
|
|
|
XCTAssertEqual(0, Core.countNonZero(src: img))
|
|
}
|
|
|
|
func testPutTextMatStringPointIntDoubleScalar() {
|
|
let text = "Hello World"
|
|
let labelSize = Size(width: 175, height: 22)
|
|
let img = Mat(rows: 20 + labelSize.height, cols: 20 + labelSize.width, type: CvType.CV_8U, scalar: colorBlack)
|
|
let origin = Point(x: 10, y: labelSize.height + 10)
|
|
|
|
Imgproc.putText(img: img, text: text, org: origin, fontFace: .FONT_HERSHEY_SIMPLEX, fontScale: 1.0, color: colorWhite)
|
|
|
|
XCTAssert(Core.countNonZero(src: img) > 0)
|
|
// check that border is not corrupted
|
|
Imgproc.rectangle(img: img, pt1: Point(x: 11, y: 11), pt2: Point(x: labelSize.width + 10, y: labelSize.height + 10), color: colorBlack, thickness: Core.FILLED)
|
|
XCTAssertEqual(0, Core.countNonZero(src: img))
|
|
}
|
|
|
|
func testPutTextMatStringPointIntDoubleScalarInt() {
|
|
let text = "Hello World"
|
|
let labelSize = Size(width: 176, height: 22)
|
|
let img = Mat(rows: 20 + labelSize.height, cols: 20 + labelSize.width, type: CvType.CV_8U, scalar: colorBlack)
|
|
let origin = Point(x: 10, y: labelSize.height + 10)
|
|
|
|
Imgproc.putText(img: img, text: text, org: origin, fontFace: .FONT_HERSHEY_SIMPLEX, fontScale: 1.0, color: colorWhite, thickness: 2)
|
|
|
|
XCTAssert(Core.countNonZero(src: img) > 0)
|
|
// check that border is not corrupted
|
|
Imgproc.rectangle(img: img, pt1: Point(x: 10, y: 10), pt2: Point(x: labelSize.width + 10 + 1, y: labelSize.height + 10 + 1), color: colorBlack, thickness: Core.FILLED)
|
|
XCTAssertEqual(0, Core.countNonZero(src: img))
|
|
}
|
|
|
|
func testPutTextMatStringPointIntDoubleScalarIntIntBoolean() {
|
|
let text = "Hello World"
|
|
let labelSize = Size(width: 175, height: 22)
|
|
|
|
let img = Mat(rows: 20 + labelSize.height, cols: 20 + labelSize.width, type: CvType.CV_8U, scalar: colorBlack)
|
|
let origin = Point(x: 10, y: 10)
|
|
|
|
Imgproc.putText(img: img, text: text, org: origin, fontFace: .FONT_HERSHEY_SIMPLEX, fontScale: 1.0, color: colorWhite, thickness: 1, lineType: .LINE_8, bottomLeftOrigin: true)
|
|
|
|
XCTAssert(Core.countNonZero(src: img) > 0)
|
|
// check that border is not corrupted
|
|
Imgproc.rectangle(img: img, pt1: Point(x: 10, y: 10), pt2: Point(x: labelSize.width + 9, y: labelSize.height + 9), color: colorBlack, thickness: Core.FILLED)
|
|
XCTAssertEqual(0, Core.countNonZero(src: img))
|
|
}
|
|
|
|
}
|