Download modules/core/misc/objc/common/MatExt.swift from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 27 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/core/misc/objc/common/MatExt.swift
- Command line
-
hf download hf://tgollogly/test/modules/core/misc/objc/common/MatExt.swift
-
curl -L -o MatExt.swift https://huggingface.co/tgollogly/test/resolve/main/modules/core/misc/objc/common/MatExt.swift
27 kB
| // | |
| // MatExt.swift | |
| // | |
| // Created by Giles Payne on 2020/01/19. | |
| // | |
| import Foundation | |
| let OpenCVErrorDomain = "OpenCVErrorDomain" | |
| enum OpenCVError : Int { | |
| case IncompatibleDataType = 10001 | |
| case IncompatibleBufferSize | |
| } | |
| func throwIncompatibleDataType(typeName: String) throws { | |
| throw NSError( | |
| domain: OpenCVErrorDomain, | |
| code: OpenCVError.IncompatibleDataType.rawValue, | |
| userInfo: [ | |
| NSLocalizedDescriptionKey: "Incompatible Mat type \(typeName)" | |
| ] | |
| ) | |
| } | |
| func throwIncompatibleBufferSize(count: Int, channels: Int32) throws { | |
| throw NSError( | |
| domain: OpenCVErrorDomain, | |
| code: OpenCVError.IncompatibleBufferSize.rawValue, | |
| userInfo: [ | |
| NSLocalizedDescriptionKey: "Provided data element number \(count) should be multiple of the Mat channels count \(channels)" | |
| ] | |
| ) | |
| } | |
| public typealias T2<T> = (T, T) | |
| public typealias T3<T> = (T, T, T) | |
| public typealias T4<T> = (T, T, T, T) | |
| public extension Mat { | |
| convenience init(rows:Int32, cols:Int32, type:Int32, data:[Int8]) { | |
| let dataObject = data.withUnsafeBufferPointer { Data(buffer: $0) } | |
| self.init(rows: rows, cols: cols, type: type, data: dataObject) | |
| } | |
| convenience init(rows:Int32, cols:Int32, type:Int32, data:[Int8], step:Int) { | |
| let dataObject = data.withUnsafeBufferPointer { Data(buffer: $0) } | |
| self.init(rows: rows, cols: cols, type: type, data: dataObject, step:step) | |
| } | |
| @discardableResult func get(indices:[Int32], data:inout [Int8]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_8U && depth() != CvType.CV_8S { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeMutableBufferPointer { body in | |
| return __get(indices as [NSNumber], count: count, byteBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func get(indices:[Int32], data:inout [UInt8]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_8U { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeMutableBufferPointer { body in | |
| body.withMemoryRebound(to: Int8.self) { reboundBody in | |
| return __get(indices as [NSNumber], count: count, byteBuffer: reboundBody.baseAddress!) | |
| } | |
| } | |
| } | |
| @discardableResult func get(indices:[Int32], data:inout [Double]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_64F { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeMutableBufferPointer { body in | |
| return __get(indices as [NSNumber], count: count, doubleBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func get(indices:[Int32], data:inout [Float]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_32F { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeMutableBufferPointer { body in | |
| return __get(indices as [NSNumber], count: count, floatBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func get(indices:[Int32], data:inout [Int32]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_32S { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeMutableBufferPointer { body in | |
| return __get(indices as [NSNumber], count: count, intBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func get(indices:[Int32], data:inout [Int16]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_16U && depth() != CvType.CV_16S { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeMutableBufferPointer { body in | |
| return __get(indices as [NSNumber], count: count, shortBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func get(indices:[Int32], data:inout [UInt16]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_16U { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeMutableBufferPointer { body in | |
| body.withMemoryRebound(to: Int16.self) { reboundBody in | |
| return __get(indices as [NSNumber], count: count, shortBuffer: reboundBody.baseAddress!) | |
| } | |
| } | |
| } | |
| @discardableResult func get(row: Int32, col: Int32, data:inout [Int8]) throws -> Int32 { | |
| return try get(indices: [row, col], data: &data) | |
| } | |
| @discardableResult func get(row: Int32, col: Int32, data:inout [UInt8]) throws -> Int32 { | |
| return try get(indices: [row, col], data: &data) | |
| } | |
| @discardableResult func get(row: Int32, col: Int32, data:inout [Double]) throws -> Int32 { | |
| return try get(indices: [row, col], data: &data) | |
| } | |
| @discardableResult func get(row: Int32, col: Int32, data:inout [Float]) throws -> Int32 { | |
| return try get(indices: [row, col], data: &data) | |
| } | |
| @discardableResult func get(row: Int32, col: Int32, data:inout [Int32]) throws -> Int32 { | |
| return try get(indices: [row, col], data: &data) | |
| } | |
| @discardableResult func get(row: Int32, col: Int32, data:inout [Int16]) throws -> Int32 { | |
| return try get(indices: [row, col], data: &data) | |
| } | |
| @discardableResult func get(row: Int32, col: Int32, data:inout [UInt16]) throws -> Int32 { | |
| return try get(indices: [row, col], data: &data) | |
| } | |
| @discardableResult func put(indices:[Int32], data:[Int8]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_8U && depth() != CvType.CV_8S { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeBufferPointer { body in | |
| return __put(indices as [NSNumber], count: count, byteBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func put(indices:[Int32], data:[UInt8]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_8U { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeBufferPointer { body in | |
| body.withMemoryRebound(to: Int8.self) { reboundBody in | |
| return __put(indices as [NSNumber], count: count, byteBuffer: reboundBody.baseAddress!) | |
| } | |
| } | |
| } | |
| @discardableResult func put(indices:[Int32], data:[Int8], offset: Int, length: Int32) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_8U && depth() != CvType.CV_8S { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| return data.withUnsafeBufferPointer { body in | |
| return __put(indices as [NSNumber], count: length, byteBuffer: body.baseAddress! + offset) | |
| } | |
| } | |
| // unlike other put:indices:data functions this one (with [Double]) should convert input values to correct type | |
| @discardableResult func put(indices:[Int32], data:[Double]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } | |
| if depth() == CvType.CV_64F { | |
| let count = Int32(data.count) | |
| return data.withUnsafeBufferPointer { body in | |
| return __put(indices as [NSNumber], count: count, doubleBuffer: body.baseAddress!) | |
| } | |
| } else { | |
| return __put(indices as [NSNumber], data: data as [NSNumber]) | |
| } | |
| } | |
| @discardableResult func put(indices:[Int32], data:[Float]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_32F { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeBufferPointer { body in | |
| return __put(indices as [NSNumber], count: count, floatBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func put(indices:[Int32], data:[Int32]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_32S { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeBufferPointer { body in | |
| return __put(indices as [NSNumber], count: count, intBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func put(indices:[Int32], data:[Int16]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_16U && depth() != CvType.CV_16S { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeBufferPointer { body in | |
| return __put(indices as [NSNumber], count: count, shortBuffer: body.baseAddress!) | |
| } | |
| } | |
| @discardableResult func put(indices:[Int32], data:[UInt16]) throws -> Int32 { | |
| let channels = CvType.channels(Int32(type())) | |
| if Int32(data.count) % channels != 0 { | |
| try throwIncompatibleBufferSize(count: data.count, channels: channels) | |
| } else if depth() != CvType.CV_16U { | |
| try throwIncompatibleDataType(typeName: CvType.type(toString: type())) | |
| } | |
| let count = Int32(data.count) | |
| return data.withUnsafeBufferPointer { body in | |
| body.withMemoryRebound(to: Int16.self) { reboundBody in | |
| return __put(indices as [NSNumber], count: count, shortBuffer: reboundBody.baseAddress!) | |
| } | |
| } | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data:[Int8]) throws -> Int32 { | |
| return try put(indices: [row, col], data: data) | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data:[UInt8]) throws -> Int32 { | |
| return try put(indices: [row, col], data: data) | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data: [Int8], offset: Int, length: Int32) throws -> Int32 { | |
| return try put(indices: [row, col], data: data, offset: offset, length: length) | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data: [Double]) throws -> Int32 { | |
| return try put(indices: [row, col], data: data) | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data: [Float]) throws -> Int32 { | |
| return try put(indices: [row, col], data: data) | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data: [Int32]) throws -> Int32 { | |
| return try put(indices: [row, col], data: data) | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data: [Int16]) throws -> Int32 { | |
| return try put(indices: [row, col], data: data) | |
| } | |
| @discardableResult func put(row: Int32, col: Int32, data: [UInt16]) throws -> Int32 { | |
| return try put(indices: [row, col], data: data) | |
| } | |
| @discardableResult func get(row: Int32, col: Int32) -> [Double] { | |
| return get(indices: [row, col]) | |
| } | |
| @discardableResult func get(indices: [Int32]) -> [Double] { | |
| return __get(indices as [NSNumber]) as! [Double] | |
| } | |
| } | |
| public protocol Atable { | |
| static func getAt(m: Mat, indices:[Int32]) -> Self | |
| static func putAt(m: Mat, indices:[Int32], v: Self) | |
| static func getAt2c(m: Mat, indices:[Int32]) -> (Self, Self) | |
| static func putAt2c(m: Mat, indices:[Int32], v: (Self, Self)) | |
| static func getAt3c(m: Mat, indices:[Int32]) -> (Self, Self, Self) | |
| static func putAt3c(m: Mat, indices:[Int32], v: (Self, Self, Self)) | |
| static func getAt4c(m: Mat, indices:[Int32]) -> (Self, Self, Self, Self) | |
| static func putAt4c(m: Mat, indices:[Int32], v: (Self, Self, Self, Self)) | |
| } | |
| public class MatAt<N: Atable> { | |
| init(mat: Mat, indices: [Int32]) { | |
| self.mat = mat | |
| self.indices = indices | |
| } | |
| private let mat: Mat | |
| private let indices: [Int32] | |
| public var v: N { | |
| get { | |
| return N.getAt(m: mat, indices: indices) | |
| } | |
| set(value) { | |
| N.putAt(m: mat, indices: indices, v: value) | |
| } | |
| } | |
| public var v2c: (N, N) { | |
| get { | |
| return N.getAt2c(m: mat, indices: indices) | |
| } | |
| set(value) { | |
| N.putAt2c(m: mat, indices: indices, v: value) | |
| } | |
| } | |
| public var v3c: (N, N, N) { | |
| get { | |
| return N.getAt3c(m: mat, indices: indices) | |
| } | |
| set(value) { | |
| N.putAt3c(m: mat, indices: indices, v: value) | |
| } | |
| } | |
| public var v4c: (N, N, N, N) { | |
| get { | |
| return N.getAt4c(m: mat, indices: indices) | |
| } | |
| set(value) { | |
| N.putAt4c(m: mat, indices: indices, v: value) | |
| } | |
| } | |
| } | |
| extension UInt8: Atable { | |
| public static func getAt(m: Mat, indices:[Int32]) -> UInt8 { | |
| var tmp = [UInt8](repeating: 0, count: 1) | |
| try! m.get(indices: indices, data: &tmp) | |
| return tmp[0] | |
| } | |
| public static func putAt(m: Mat, indices: [Int32], v: UInt8) { | |
| let tmp = [v] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt2c(m: Mat, indices:[Int32]) -> (UInt8, UInt8) { | |
| var tmp = [UInt8](repeating: 0, count: 2) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1]) | |
| } | |
| public static func putAt2c(m: Mat, indices: [Int32], v: (UInt8, UInt8)) { | |
| let tmp = [v.0, v.1] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt3c(m: Mat, indices:[Int32]) -> (UInt8, UInt8, UInt8) { | |
| var tmp = [UInt8](repeating: 0, count: 3) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2]) | |
| } | |
| public static func putAt3c(m: Mat, indices: [Int32], v: (UInt8, UInt8, UInt8)) { | |
| let tmp = [v.0, v.1, v.2] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt4c(m: Mat, indices:[Int32]) -> (UInt8, UInt8, UInt8, UInt8) { | |
| var tmp = [UInt8](repeating: 0, count: 4) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2], tmp[3]) | |
| } | |
| public static func putAt4c(m: Mat, indices: [Int32], v: (UInt8, UInt8, UInt8, UInt8)) { | |
| let tmp = [v.0, v.1, v.2, v.3] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| } | |
| extension Int8: Atable { | |
| public static func getAt(m: Mat, indices:[Int32]) -> Int8 { | |
| var tmp = [Int8](repeating: 0, count: 1) | |
| try! m.get(indices: indices, data: &tmp) | |
| return tmp[0] | |
| } | |
| public static func putAt(m: Mat, indices: [Int32], v: Int8) { | |
| let tmp = [v] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt2c(m: Mat, indices:[Int32]) -> (Int8, Int8) { | |
| var tmp = [Int8](repeating: 0, count: 2) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1]) | |
| } | |
| public static func putAt2c(m: Mat, indices: [Int32], v: (Int8, Int8)) { | |
| let tmp = [v.0, v.1] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt3c(m: Mat, indices:[Int32]) -> (Int8, Int8, Int8) { | |
| var tmp = [Int8](repeating: 0, count: 3) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2]) | |
| } | |
| public static func putAt3c(m: Mat, indices: [Int32], v: (Int8, Int8, Int8)) { | |
| let tmp = [v.0, v.1, v.2] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt4c(m: Mat, indices:[Int32]) -> (Int8, Int8, Int8, Int8) { | |
| var tmp = [Int8](repeating: 0, count: 4) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2], tmp[3]) | |
| } | |
| public static func putAt4c(m: Mat, indices: [Int32], v: (Int8, Int8, Int8, Int8)) { | |
| let tmp = [v.0, v.1, v.2, v.3] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| } | |
| extension Double: Atable { | |
| public static func getAt(m: Mat, indices:[Int32]) -> Double { | |
| var tmp = [Double](repeating: 0, count: 1) | |
| try! m.get(indices: indices, data: &tmp) | |
| return tmp[0] | |
| } | |
| public static func putAt(m: Mat, indices: [Int32], v: Double) { | |
| let tmp = [v] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt2c(m: Mat, indices:[Int32]) -> (Double, Double) { | |
| var tmp = [Double](repeating: 0, count: 2) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1]) | |
| } | |
| public static func putAt2c(m: Mat, indices: [Int32], v: (Double, Double)) { | |
| let tmp = [v.0, v.1] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt3c(m: Mat, indices:[Int32]) -> (Double, Double, Double) { | |
| var tmp = [Double](repeating: 0, count: 3) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2]) | |
| } | |
| public static func putAt3c(m: Mat, indices: [Int32], v: (Double, Double, Double)) { | |
| let tmp = [v.0, v.1, v.2] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt4c(m: Mat, indices:[Int32]) -> (Double, Double, Double, Double) { | |
| var tmp = [Double](repeating: 0, count: 4) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2], tmp[3]) | |
| } | |
| public static func putAt4c(m: Mat, indices: [Int32], v: (Double, Double, Double, Double)) { | |
| let tmp = [v.0, v.1, v.2, v.3] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| } | |
| extension Float: Atable { | |
| public static func getAt(m: Mat, indices:[Int32]) -> Float { | |
| var tmp = [Float](repeating: 0, count: 1) | |
| try! m.get(indices: indices, data: &tmp) | |
| return tmp[0] | |
| } | |
| public static func putAt(m: Mat, indices: [Int32], v: Float) { | |
| let tmp = [v] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt2c(m: Mat, indices:[Int32]) -> (Float, Float) { | |
| var tmp = [Float](repeating: 0, count: 2) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1]) | |
| } | |
| public static func putAt2c(m: Mat, indices: [Int32], v: (Float, Float)) { | |
| let tmp = [v.0, v.1] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt3c(m: Mat, indices:[Int32]) -> (Float, Float, Float) { | |
| var tmp = [Float](repeating: 0, count: 3) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2]) | |
| } | |
| public static func putAt3c(m: Mat, indices: [Int32], v: (Float, Float, Float)) { | |
| let tmp = [v.0, v.1, v.2] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt4c(m: Mat, indices:[Int32]) -> (Float, Float, Float, Float) { | |
| var tmp = [Float](repeating: 0, count: 4) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2], tmp[3]) | |
| } | |
| public static func putAt4c(m: Mat, indices: [Int32], v: (Float, Float, Float, Float)) { | |
| let tmp = [v.0, v.1, v.2, v.3] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| } | |
| extension Int32: Atable { | |
| public static func getAt(m: Mat, indices:[Int32]) -> Int32 { | |
| var tmp = [Int32](repeating: 0, count: 1) | |
| try! m.get(indices: indices, data: &tmp) | |
| return tmp[0] | |
| } | |
| public static func putAt(m: Mat, indices: [Int32], v: Int32) { | |
| let tmp = [v] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt2c(m: Mat, indices:[Int32]) -> (Int32, Int32) { | |
| var tmp = [Int32](repeating: 0, count: 2) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1]) | |
| } | |
| public static func putAt2c(m: Mat, indices: [Int32], v: (Int32, Int32)) { | |
| let tmp = [v.0, v.1] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt3c(m: Mat, indices:[Int32]) -> (Int32, Int32, Int32) { | |
| var tmp = [Int32](repeating: 0, count: 3) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2]) | |
| } | |
| public static func putAt3c(m: Mat, indices: [Int32], v: (Int32, Int32, Int32)) { | |
| let tmp = [v.0, v.1, v.2] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt4c(m: Mat, indices:[Int32]) -> (Int32, Int32, Int32, Int32) { | |
| var tmp = [Int32](repeating: 0, count: 4) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2], tmp[3]) | |
| } | |
| public static func putAt4c(m: Mat, indices: [Int32], v: (Int32, Int32, Int32, Int32)) { | |
| let tmp = [v.0, v.1, v.2, v.3] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| } | |
| extension UInt16: Atable { | |
| public static func getAt(m: Mat, indices:[Int32]) -> UInt16 { | |
| var tmp = [UInt16](repeating: 0, count: 1) | |
| try! m.get(indices: indices, data: &tmp) | |
| return tmp[0] | |
| } | |
| public static func putAt(m: Mat, indices: [Int32], v: UInt16) { | |
| let tmp = [v] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt2c(m: Mat, indices:[Int32]) -> (UInt16, UInt16) { | |
| var tmp = [UInt16](repeating: 0, count: 2) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1]) | |
| } | |
| public static func putAt2c(m: Mat, indices: [Int32], v: (UInt16, UInt16)) { | |
| let tmp = [v.0, v.1] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt3c(m: Mat, indices:[Int32]) -> (UInt16, UInt16, UInt16) { | |
| var tmp = [UInt16](repeating: 0, count: 3) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2]) | |
| } | |
| public static func putAt3c(m: Mat, indices: [Int32], v: (UInt16, UInt16, UInt16)) { | |
| let tmp = [v.0, v.1, v.2] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt4c(m: Mat, indices:[Int32]) -> (UInt16, UInt16, UInt16, UInt16) { | |
| var tmp = [UInt16](repeating: 0, count: 4) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2], tmp[3]) | |
| } | |
| public static func putAt4c(m: Mat, indices: [Int32], v: (UInt16, UInt16, UInt16, UInt16)) { | |
| let tmp = [v.0, v.1, v.2, v.3] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| } | |
| extension Int16: Atable { | |
| public static func getAt(m: Mat, indices:[Int32]) -> Int16 { | |
| var tmp = [Int16](repeating: 0, count: 1) | |
| try! m.get(indices: indices, data: &tmp) | |
| return tmp[0] | |
| } | |
| public static func putAt(m: Mat, indices: [Int32], v: Int16) { | |
| let tmp = [v] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt2c(m: Mat, indices:[Int32]) -> (Int16, Int16) { | |
| var tmp = [Int16](repeating: 0, count: 2) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1]) | |
| } | |
| public static func putAt2c(m: Mat, indices: [Int32], v: (Int16, Int16)) { | |
| let tmp = [v.0, v.1] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt3c(m: Mat, indices:[Int32]) -> (Int16, Int16, Int16) { | |
| var tmp = [Int16](repeating: 0, count: 3) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2]) | |
| } | |
| public static func putAt3c(m: Mat, indices: [Int32], v: (Int16, Int16, Int16)) { | |
| let tmp = [v.0, v.1, v.2] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| public static func getAt4c(m: Mat, indices:[Int32]) -> (Int16, Int16, Int16, Int16) { | |
| var tmp = [Int16](repeating: 0, count: 4) | |
| try! m.get(indices: indices, data: &tmp) | |
| return (tmp[0], tmp[1], tmp[2], tmp[3]) | |
| } | |
| public static func putAt4c(m: Mat, indices: [Int32], v: (Int16, Int16, Int16, Int16)) { | |
| let tmp = [v.0, v.1, v.2, v.3] | |
| try! m.put(indices: indices, data: tmp) | |
| } | |
| } | |
| /*** | |
| * Example use: | |
| * | |
| * let elemantVal: UInt8 = mat.at(row: 50, col: 50).v | |
| * mat.at(row: 50, col: 50).v = 245 | |
| * | |
| */ | |
| public extension Mat { | |
| func at<N: Atable>(row: Int32, col: Int32) -> MatAt<N> { | |
| return MatAt(mat: self, indices: [row, col]) | |
| } | |
| func at<N: Atable>(indices:[Int32]) -> MatAt<N> { | |
| return MatAt(mat: self, indices: indices) | |
| } | |
| } | |
| public extension Mat { | |
| static func *(lhs:Mat, rhs: Mat) -> Mat { | |
| return lhs.matMul(rhs) | |
| } | |
| } | |