capacitor-plugin-faceantispoofing 0.0.1

package/ios/Sources/FaceAntiSpoofingPlugin/MTCNN.swift

@@ -0,0 +1,407 @@
+import Foundation
+import UIKit
+import TensorFlowLite
+
+public class MTCNN {
+    private static let pnetModelFileName = "pnet"
+    private static let rnetModelFileName = "rnet"
+    private static let onetModelFileName = "onet"
+    private static let modelFileType = "tflite"
+
+    private static let factor: Float = 0.709
+    private static let pNetThreshold: Float = 0.6
+    private static let rNetThreshold: Float = 0.7
+    private static let oNetThreshold: Float = 0.7
+
+    private var pnetInterpreter: Interpreter?
+    private var rnetInterpreter: Interpreter?
+    private var onetInterpreter: Interpreter?
+
+    public init() throws {
+        var options = InterpreterOptions()
+        options.numberOfThreads = 4
+
+        let pnetModelPath = Tools.filePathForResourceName(name: Self.pnetModelFileName, extension: Self.modelFileType)
+        let rnetModelPath = Tools.filePathForResourceName(name: Self.rnetModelFileName, extension: Self.modelFileType)
+        let onetModelPath = Tools.filePathForResourceName(name: Self.onetModelFileName, extension: Self.modelFileType)
+
+        pnetInterpreter = try Interpreter(modelPath: pnetModelPath, options: options)
+        rnetInterpreter = try Interpreter(modelPath: rnetModelPath, options: options)
+        onetInterpreter = try Interpreter(modelPath: onetModelPath, options: options)
+    }
+
+    public func detectFaces(image: UIImage, minFaceSize: CGFloat) -> [Box] {
+        var boxes = pNet(image: image, minSize: minFaceSize)
+        squareLimit(boxes: &boxes, w: Int(image.size.width), h: Int(image.size.height))
+
+        boxes = rNet(image: image, boxes: boxes)
+        squareLimit(boxes: &boxes, w: Int(image.size.width), h: Int(image.size.height))
+
+        boxes = oNet(image: image, boxes: boxes)
+
+        return boxes
+    }
+
+    private func squareLimit(boxes: inout [Box], w: Int, h: Int) {
+        for i in 0..<boxes.count {
+            boxes[i].toSquareShape()
+            boxes[i].limitSquare(w: w, h: h)
+        }
+    }
+
+    // MARK: - PNet
+
+    private func pNet(image: UIImage, minSize: CGFloat) -> [Box] {
+        let whMin = min(image.size.width, image.size.height)
+        var currentFaceSize = minSize
+        var totalBoxes: [Box] = []
+
+        while currentFaceSize <= whMin {
+            let scale = 12.0 / currentFaceSize
+
+            guard let img = Tools.scaleImage(image: image, toScale: scale) else {
+                currentFaceSize /= Self.factor
+                continue
+            }
+
+            let w = Int(img.size.width)
+            let h = Int(img.size.height)
+
+            let outW = Int(ceil(CGFloat(w) * 0.5 - 5) + 0.5)
+            let outH = Int(ceil(CGFloat(h) * 0.5 - 5) + 0.5)
+
+            guard let (prob1, conv4_2) = pNetForward(image: img, w: w, h: h, outW: outW, outH: outH) else {
+                currentFaceSize /= Self.factor
+                continue
+            }
+
+            var curBoxes: [Box] = []
+            generateBoxes(prob1: prob1, conv4_2: conv4_2, scale: scale, boxes: &curBoxes)
+
+            nms(boxes: &curBoxes, threshold: 0.5, method: "Union")
+
+            for box in curBoxes {
+                if !box.deleted {
+                    totalBoxes.append(box)
+                }
+            }
+
+            currentFaceSize /= Self.factor
+        }
+
+        nms(boxes: &totalBoxes, threshold: 0.7, method: "Union")
+        boundingBoxRegression(boxes: &totalBoxes)
+
+        return updateBoxes(boxes: totalBoxes)
+    }
+
+    private func pNetForward(image: UIImage, w: Int, h: Int, outW: Int, outH: Int) -> ([[Float]], [[Float]])? {
+        guard let interpreter = pnetInterpreter else { return nil }
+
+        guard let floats = normalizeImage(image: image, w: w, h: h) else { return nil }
+        let transposed = transpose(data: floats, h: h, w: w, c: 3)
+
+        let inputData = Data(bytes: transposed, count: w * h * 3 * MemoryLayout<Float>.size)
+
+        do {
+            try interpreter.resizeInput(at: 0, to: [1, w, h, 3])
+            try interpreter.allocateTensors()
+            try interpreter.copy(inputData, toInputAt: 0)
+            try interpreter.invoke()
+
+            guard let prob1Data = try interpreter.output(at: 0) as? [Float],
+                  let conv4_2Data = try interpreter.output(at: 1) as? [Float] else {
+                return nil
+            }
+
+            let prob1 = reshapeTo2D(data: prob1Data, rows: outW, cols: outH * 2)
+            let conv4_2 = reshapeTo2D(data: conv4_2Data, rows: outW, cols: outH * 4)
+
+            let prob1T = transpose2D(data: prob1, rows: outW, cols: outH * 2)
+            let conv4_2T = transpose2D(data: conv4_2, rows: outW, cols: outH * 4)
+
+            return (prob1T, conv4_2T)
+        } catch {
+            print("PNet forward error: \(error)")
+            return nil
+        }
+    }
+
+    private func generateBoxes(prob1: [[Float]], conv4_2: [[Float]], scale: CGFloat, boxes: inout [Box]) {
+        let h = prob1.count
+        let w = prob1[0].count / 2
+
+        for y in 0..<h {
+            for x in 0..<w {
+                let score = prob1[y][x * 2 + 1]
+                if score > Self.pNetThreshold {
+                    let box = Box()
+                    box.score = score
+                    box.box[0] = Int(round(CGFloat(x * 2) / scale))
+                    box.box[1] = Int(round(CGFloat(y * 2) / scale))
+                    box.box[2] = Int(round(CGFloat(x * 2 + 11) / scale))
+                    box.box[3] = Int(round(CGFloat(y * 2 + 11) / scale))
+                    for i in 0..<4 {
+                        box.bbr[i] = conv4_2[y][x * 4 + i]
+                    }
+                    boxes.append(box)
+                }
+            }
+        }
+    }
+
+    // MARK: - RNet
+
+    private func rNet(image: UIImage, boxes: [Box]) -> [Box] {
+        guard let interpreter = rnetInterpreter else { return boxes }
+
+        let num = boxes.count
+        var rNetIn = [[Float]]()
+
+        for i in 0..<num {
+            guard let cropped = crop(image: image, with: boxes[i], andScale: 24) else { continue }
+            if let normalized = normalizeImage(image: cropped, w: 24, h: 24) {
+                let transposed = transpose(data: normalized, h: 24, w: 24, c: 3)
+                rNetIn.append(transposed)
+            }
+        }
+
+        guard let (prob1, conv5_2) = rNetForward(interpreter: interpreter, input: rNetIn, num: num) else {
+            return boxes
+        }
+
+        var result = boxes
+        for i in 0..<num {
+            result[i].score = prob1[i][1]
+            for j in 0..<4 {
+                result[i].bbr[j] = conv5_2[i][j]
+            }
+        }
+
+        for i in 0..<result.count {
+            if result[i].score < Self.rNetThreshold {
+                result[i].deleted = true
+            }
+        }
+
+        nms(boxes: &result, threshold: 0.7, method: "Union")
+        boundingBoxRegression(boxes: &result)
+
+        return updateBoxes(boxes: result)
+    }
+
+    private func rNetForward(interpreter: Interpreter, input: [[Float]], num: Int) -> ([[Float]], [[Float]])? {
+        var prob1 = [[Float]](repeating: [Float](repeating: 0, count: 2), count: num)
+        var conv5_2 = [[Float]](repeating: [Float](repeating: 0, count: 4), count: num)
+
+        do {
+            try interpreter.allocateTensors()
+
+            for i in 0..<num {
+                let inputData = Data(bytes: input[i], count: 24 * 24 * 3 * MemoryLayout<Float>.size)
+                try interpreter.copy(inputData, toInputAt: 0)
+                try interpreter.invoke()
+
+                guard let prob1Data = try interpreter.output(at: 0) as? [Float],
+                      let conv5_2Data = try interpreter.output(at: 1) as? [Float] else {
+                    continue
+                }
+
+                prob1[i] = [prob1Data[0], prob1Data[1]]
+                conv5_2[i] = [conv5_2Data[0], conv5_2Data[1], conv5_2Data[2], conv5_2Data[3]]
+            }
+
+            return (prob1, conv5_2)
+        } catch {
+            print("RNet forward error: \(error)")
+            return nil
+        }
+    }
+
+    // MARK: - ONet
+
+    private func oNet(image: UIImage, boxes: [Box]) -> [Box] {
+        guard let interpreter = onetInterpreter else { return boxes }
+
+        let num = boxes.count
+        var oNetIn = [[Float]]()
+
+        for i in 0..<num {
+            guard let cropped = crop(image: image, with: boxes[i], andScale: 48) else { continue }
+            if let normalized = normalizeImage(image: cropped, w: 48, h: 48) {
+                let transposed = transpose(data: normalized, h: 48, w: 48, c: 3)
+                oNetIn.append(transposed)
+            }
+        }
+
+        guard let (prob1, conv6_2, conv6_3) = oNetForward(interpreter: interpreter, input: oNetIn, num: num) else {
+            return boxes
+        }
+
+        var result = boxes
+        for i in 0..<num {
+            result[i].score = prob1[i][1]
+            for j in 0..<4 {
+                result[i].bbr[j] = conv6_2[i][j]
+            }
+            for j in 0..<5 {
+                let x = Int(round(CGFloat(result[i].left()) + CGFloat(conv6_3[i][j]) * CGFloat(result[i].width())))
+                let y = Int(round(CGFloat(result[i].top()) + CGFloat(conv6_3[i][j + 5]) * CGFloat(result[i].height())))
+                result[i].landmark[j] = CGPoint(x: x, y: y)
+            }
+        }
+
+        for i in 0..<result.count {
+            if result[i].score < Self.oNetThreshold {
+                result[i].deleted = true
+            }
+        }
+
+        boundingBoxRegression(boxes: &result)
+        nms(boxes: &result, threshold: 0.7, method: "Min")
+
+        return updateBoxes(boxes: result)
+    }
+
+    private func oNetForward(interpreter: Interpreter, input: [[Float]], num: Int) -> ([[Float]], [[Float]], [[Float]])? {
+        var prob1 = [[Float]](repeating: [Float](repeating: 0, count: 2), count: num)
+        var conv6_2 = [[Float]](repeating: [Float](repeating: 0, count: 4), count: num)
+        var conv6_3 = [[Float]](repeating: [Float](repeating: 0, count: 10), count: num)
+
+        do {
+            try interpreter.allocateTensors()
+
+            for i in 0..<num {
+                let inputData = Data(bytes: input[i], count: 48 * 48 * 3 * MemoryLayout<Float>.size)
+                try interpreter.copy(inputData, toInputAt: 0)
+                try interpreter.invoke()
+
+                guard let prob1Data = try interpreter.output(at: 0) as? [Float],
+                      let conv6_2Data = try interpreter.output(at: 1) as? [Float],
+                      let conv6_3Data = try interpreter.output(at: 2) as? [Float] else {
+                    continue
+                }
+
+                prob1[i] = [prob1Data[0], prob1Data[1]]
+                conv6_2[i] = [conv6_2Data[0], conv6_2Data[1], conv6_2Data[2], conv6_2Data[3]]
+                for j in 0..<10 {
+                    conv6_3[i][j] = conv6_3Data[j]
+                }
+            }
+
+            return (prob1, conv6_2, conv6_3)
+        } catch {
+            print("ONet forward error: \(error)")
+            return nil
+        }
+    }
+
+    // MARK: - Utility functions
+
+    private func nms(boxes: inout [Box], threshold: Float, method: String) {
+        for i in 0..<boxes.count {
+            let box = boxes[i]
+            if !box.deleted {
+                for j in (i + 1)..<boxes.count {
+                    let box2 = boxes[j]
+                    if !box2.deleted {
+                        let x1 = CGFloat(max(box.box[0], box2.box[0]))
+                        let y1 = CGFloat(max(box.box[1], box2.box[1]))
+                        let x2 = CGFloat(min(box.box[2], box2.box[2]))
+                        let y2 = CGFloat(min(box.box[3], box2.box[3]))
+
+                        if x2 < x1 || y2 < y1 { continue }
+
+                        let areaIoU = Int((x2 - x1 + 1) * (y2 - y1 + 1))
+                        var iou: Float = 0
+
+                        if method == "Union" {
+                            iou = Float(areaIoU) / Float(box.area() + box2.area() - areaIoU)
+                        } else if method == "Min" {
+                            iou = Float(areaIoU) / Float(min(box.area(), box2.area()))
+                        }
+
+                        if iou >= threshold {
+                            if box.score > box2.score {
+                                box2.deleted = true
+                            } else {
+                                box.deleted = true
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private func boundingBoxRegression(boxes: inout [Box]) {
+        for i in 0..<boxes.count {
+            boxes[i].calibrate()
+        }
+    }
+
+    private func updateBoxes(boxes: [Box]) -> [Box] {
+        return boxes.filter { !$0.deleted }
+    }
+
+    private func crop(image: UIImage, with box: Box, andScale size: Int) -> UIImage? {
+        let rect = box.transform2Rect()
+        guard let cropped = Tools.cropImage(image: image, toRect: rect) else { return nil }
+        return Tools.scaleImage(image: cropped, toSize: CGSize(width: size, height: size))
+    }
+
+    private func normalizeImage(image: UIImage, w: Int, h: Int) -> [Float]? {
+        guard let image_data = Tools.convertUIImageToBitmapRGBA8(image: image) else { return nil }
+
+        let inputMean: Float = 127.5
+        let inputStd: Float = 128.0
+        var floats = [Float](repeating: 0, count: w * h * 3)
+
+        var k = 0
+        let size = w * h * 4
+        for j in 0..<size {
+            if j % 4 == 3 { continue }
+            let val = Float(image_data[j])
+            let r = ((val > 16) & 0xFF) - inputMean
+            let g = ((val > 8) & 0xFF) - inputMean
+            let b = (val & 0xFF) - inputMean
+            floats[k] = r / inputStd
+            k += 1
+        }
+        image_data.deallocate()
+
+        return floats
+    }
+
+    private func transpose(data: [Float], h: Int, w: Int, c: Int) -> [Float] {
+        var result = [Float](repeating: 0, count: w * h * c)
+        for i in 0..<h {
+            for j in 0..<w {
+                for z in 0..<c {
+                    result[(j * h + i) * c + z] = data[(i * w + j) * c + z]
+                }
+            }
+        }
+        return result
+    }
+
+    private func transpose2D(data: [[Float]], rows: Int, cols: Int) -> [[Float]] {
+        var result = [[Float]](repeating: [Float](repeating: 0, count: cols), count: rows)
+        for i in 0..<rows {
+            for j in 0..<cols {
+                result[j][i] = data[i][j]
+            }
+        }
+        return result
+    }
+
+    private func reshapeTo2D(data: [Float], rows: Int, cols: Int) -> [[Float]] {
+        var result = [[Float]](repeating: [Float](repeating: 0, count: cols), count: rows)
+        for i in 0..<rows {
+            for j in 0..<cols {
+                result[i][j] = data[i * cols + j]
+            }
+        }
+        return result
+    }
+}

package/ios/Sources/FaceAntiSpoofingPlugin/Tools.swift

@@ -0,0 +1,103 @@
+import Foundation
+import UIKit
+
+public class Tools {
+    public static func filePathForResourceName(name: String, extension ext: String) -> String {
+        let bundle = Bundle(for: FaceAntiSpoofingPlugin.self)
+        guard let resourcePath = bundle.path(forResource: name, ofType: ext) else {
+            fatalError("Resource not found: \(name).\(ext)")
+        }
+        return resourcePath
+    }
+
+    public static func convertUIImageToBitmapRGBA8(image: UIImage) -> UnsafeMutablePointer<UInt8>? {
+        guard let cgImage = image.cgImage else {
+            return nil
+        }
+
+        let width = cgImage.width
+        let height = cgImage.height
+        let bitsPerComponent = 8
+        let bytesPerRow = width * 4
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+
+        var bitmapInfo = CGImageAlphaInfo.premultipliedLast.rawValue
+        bitmapInfo |= CGBitmapInfo.byteOrder32Big.rawValue
+
+        guard let context = CGContext(
+            data: nil,
+            width: width,
+            height: height,
+            bitsPerComponent: bitsPerComponent,
+            bytesPerRow: bytesPerRow,
+            space: colorSpace,
+            bitmapInfo: bitmapInfo
+        ) else {
+            return nil
+        }
+
+        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+
+        guard let data = context.data else {
+            return nil
+        }
+
+        return data.bindMemory(to: UInt8.self, capacity: width * height * 4)
+    }
+
+    public static func convertUIImageToBitmapGray(image: UIImage) -> UnsafeMutablePointer<UInt8>? {
+        guard let cgImage = image.cgImage else {
+            return nil
+        }
+
+        let width = cgImage.width
+        let height = cgImage.height
+        let bitsPerComponent = 8
+        let bytesPerRow = width
+        let colorSpace = CGColorSpaceCreateDeviceGray()
+
+        guard let context = CGContext(
+            data: nil,
+            width: width,
+            height: height,
+            bitsPerComponent: bitsPerComponent,
+            bytesPerRow: bytesPerRow,
+            space: colorSpace,
+            bitmapInfo: 0
+        ) else {
+            return nil
+        }
+
+        let rect = CGRect(x: 0, y: 0, width: width, height: height)
+        context.draw(cgImage, in: rect)
+
+        guard let data = context.data else {
+            return nil
+        }
+
+        let ptr = data.bindMemory(to: UInt8.self, capacity: width * height)
+        let result = UnsafeMutablePointer<UInt8>.allocate(capacity: width * height)
+        memcpy(result, ptr, width * height)
+
+        return result
+    }
+
+    public static func scaleImage(image: UIImage, toSize size: CGSize) -> UIImage? {
+        UIGraphicsBeginImageContextWithOptions(size, false, 1.0)
+        defer { UIGraphicsEndImageContext() }
+        image.draw(in: CGRect(origin: .zero, size: size))
+        return UIGraphicsGetImageFromCurrentImageContext()
+    }
+
+    public static func scaleImage(image: UIImage, toScale scale: CGFloat) -> UIImage? {
+        let newSize = CGSize(width: image.size.width * scale, height: image.size.height * scale)
+        return scaleImage(image: image, toSize: newSize)
+    }
+
+    public static func cropImage(image: UIImage, toRect rect: CGRect) -> UIImage? {
+        guard let cgImage = image.cgImage?.cropping(to: rect) else {
+            return nil
+        }
+        return UIImage(cgImage: cgImage)
+    }
+}

package/ios/Tests/FaceAntiSpoofingPluginTests/FaceAntiSpoofingTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import FaceAntiSpoofingPlugin
+
+class FaceAntiSpoofingTests: XCTestCase {
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let implementation = FaceAntiSpoofing()
+        let value = "Hello, World!"
+        let result = implementation.echo(value)
+
+        XCTAssertEqual(value, result)
+    }
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "capacitor-plugin-faceantispoofing",
+  "version": "0.0.1",
+  "description": "Capacitor plugin for Passive Liveness Detection and Face Anti-Spoofing",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapacitorPluginFaceantispoofing.podspec"
+  ],
+  "author": "Asep Herman Nursalam",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asephermann/capacitor-plugin-faceantispoofing.git"
+  },
+  "bugs": {
+    "url": "https://github.com/asephermann/capacitor-plugin-faceantispoofing/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapacitorPluginFaceantispoofing -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api FaceAntiSpoofingPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.1",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^8.57.1",
+    "prettier": "^3.6.2",
+    "prettier-plugin-java": "^2.7.7",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.53.2",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}