capacitor-plugin-faceantispoofing 0.0.1

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["export interface DetectionResult {\n  error: boolean;\n  liveness: boolean;\n  score: string;\n  threshold: string;\n  message: string;\n}\n\nexport interface DetectOptions {\n  /**\n   * Base64 encoded image data (without data:image/...;base64, prefix)\n   * or file URI to the image\n   */\n  image: string;\n}\n\nexport interface FaceAntiSpoofingPlugin {\n  /**\n   * Detect face liveness and anti-spoofing\n   * @param options Image data as base64 string or file URI\n   * @returns Promise with detection result containing liveness status\n   */\n  detect(options: DetectOptions): Promise<DetectionResult>;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { FaceAntiSpoofingPlugin } from './definitions';
+declare const FaceAntiSpoofing: FaceAntiSpoofingPlugin;
+export * from './definitions';
+export { FaceAntiSpoofing };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const FaceAntiSpoofing = registerPlugin('FaceAntiSpoofing', {
+    web: () => import('./web').then((m) => new m.FaceAntiSpoofingWeb()),
+});
+export * from './definitions';
+export { FaceAntiSpoofing };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,gBAAgB,GAAG,cAAc,CAAyB,kBAAkB,EAAE;IAClF,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,mBAAmB,EAAE,CAAC;CACpE,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,CAAC","sourcesContent":["import { registerPlugin } from '@capacitor/core';\n\nimport type { FaceAntiSpoofingPlugin } from './definitions';\n\nconst FaceAntiSpoofing = registerPlugin<FaceAntiSpoofingPlugin>('FaceAntiSpoofing', {\n  web: () => import('./web').then((m) => new m.FaceAntiSpoofingWeb()),\n});\n\nexport * from './definitions';\nexport { FaceAntiSpoofing };\n"]}

package/dist/esm/web.d.ts

@@ -0,0 +1,5 @@
+import { WebPlugin } from '@capacitor/core';
+import type { DetectionResult, DetectOptions, FaceAntiSpoofingPlugin } from './definitions';
+export declare class FaceAntiSpoofingWeb extends WebPlugin implements FaceAntiSpoofingPlugin {
+    detect(_options: DetectOptions): Promise<DetectionResult>;
+}

package/dist/esm/web.js

@@ -0,0 +1,14 @@
+import { WebPlugin } from '@capacitor/core';
+export class FaceAntiSpoofingWeb extends WebPlugin {
+    async detect(_options) {
+        console.log('Face anti-spoofing is not supported on web platform');
+        return {
+            error: true,
+            liveness: false,
+            score: '0',
+            threshold: '0',
+            message: 'Face anti-spoofing is not supported on web platform. Please use a native platform (iOS or Android).',
+        };
+    }
+}
+//# sourceMappingURL=web.js.map

package/dist/esm/web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.js","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,OAAO,mBAAoB,SAAQ,SAAS;IAChD,KAAK,CAAC,MAAM,CAAC,QAAuB;QAClC,OAAO,CAAC,GAAG,CAAC,qDAAqD,CAAC,CAAC;QACnE,OAAO;YACL,KAAK,EAAE,IAAI;YACX,QAAQ,EAAE,KAAK;YACf,KAAK,EAAE,GAAG;YACV,SAAS,EAAE,GAAG;YACd,OAAO,EAAE,qGAAqG;SAC/G,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { WebPlugin } from '@capacitor/core';\n\nimport type { DetectionResult, DetectOptions, FaceAntiSpoofingPlugin } from './definitions';\n\nexport class FaceAntiSpoofingWeb extends WebPlugin implements FaceAntiSpoofingPlugin {\n  async detect(_options: DetectOptions): Promise<DetectionResult> {\n    console.log('Face anti-spoofing is not supported on web platform');\n    return {\n      error: true,\n      liveness: false,\n      score: '0',\n      threshold: '0',\n      message: 'Face anti-spoofing is not supported on web platform. Please use a native platform (iOS or Android).',\n    };\n  }\n}\n"]}

package/dist/plugin.cjs.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+const FaceAntiSpoofing = core.registerPlugin('FaceAntiSpoofing', {
+    web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.FaceAntiSpoofingWeb()),
+});
+
+class FaceAntiSpoofingWeb extends core.WebPlugin {
+    async detect(_options) {
+        console.log('Face anti-spoofing is not supported on web platform');
+        return {
+            error: true,
+            liveness: false,
+            score: '0',
+            threshold: '0',
+            message: 'Face anti-spoofing is not supported on web platform. Please use a native platform (iOS or Android).',
+        };
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FaceAntiSpoofingWeb: FaceAntiSpoofingWeb
+});
+
+exports.FaceAntiSpoofing = FaceAntiSpoofing;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst FaceAntiSpoofing = registerPlugin('FaceAntiSpoofing', {\n    web: () => import('./web').then((m) => new m.FaceAntiSpoofingWeb()),\n});\nexport * from './definitions';\nexport { FaceAntiSpoofing };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class FaceAntiSpoofingWeb extends WebPlugin {\n    async detect(_options) {\n        console.log('Face anti-spoofing is not supported on web platform');\n        return {\n            error: true,\n            liveness: false,\n            score: '0',\n            threshold: '0',\n            message: 'Face anti-spoofing is not supported on web platform. Please use a native platform (iOS or Android).',\n        };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AACK,MAAC,gBAAgB,GAAGA,mBAAc,CAAC,kBAAkB,EAAE;AAC5D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,mBAAmB,EAAE,CAAC;AACvE,CAAC;;ACFM,MAAM,mBAAmB,SAASC,cAAS,CAAC;AACnD,IAAI,MAAM,MAAM,CAAC,QAAQ,EAAE;AAC3B,QAAQ,OAAO,CAAC,GAAG,CAAC,qDAAqD,CAAC;AAC1E,QAAQ,OAAO;AACf,YAAY,KAAK,EAAE,IAAI;AACvB,YAAY,QAAQ,EAAE,KAAK;AAC3B,YAAY,KAAK,EAAE,GAAG;AACtB,YAAY,SAAS,EAAE,GAAG;AAC1B,YAAY,OAAO,EAAE,qGAAqG;AAC1H,SAAS;AACT,IAAI;AACJ;;;;;;;;;"}

package/dist/plugin.js

@@ -0,0 +1,31 @@
+var capacitorFaceAntiSpoofing = (function (exports, core) {
+    'use strict';
+
+    const FaceAntiSpoofing = core.registerPlugin('FaceAntiSpoofing', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.FaceAntiSpoofingWeb()),
+    });
+
+    class FaceAntiSpoofingWeb extends core.WebPlugin {
+        async detect(_options) {
+            console.log('Face anti-spoofing is not supported on web platform');
+            return {
+                error: true,
+                liveness: false,
+                score: '0',
+                threshold: '0',
+                message: 'Face anti-spoofing is not supported on web platform. Please use a native platform (iOS or Android).',
+            };
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        FaceAntiSpoofingWeb: FaceAntiSpoofingWeb
+    });
+
+    exports.FaceAntiSpoofing = FaceAntiSpoofing;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst FaceAntiSpoofing = registerPlugin('FaceAntiSpoofing', {\n    web: () => import('./web').then((m) => new m.FaceAntiSpoofingWeb()),\n});\nexport * from './definitions';\nexport { FaceAntiSpoofing };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\nexport class FaceAntiSpoofingWeb extends WebPlugin {\n    async detect(_options) {\n        console.log('Face anti-spoofing is not supported on web platform');\n        return {\n            error: true,\n            liveness: false,\n            score: '0',\n            threshold: '0',\n            message: 'Face anti-spoofing is not supported on web platform. Please use a native platform (iOS or Android).',\n        };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;AACK,UAAC,gBAAgB,GAAGA,mBAAc,CAAC,kBAAkB,EAAE;IAC5D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,mBAAmB,EAAE,CAAC;IACvE,CAAC;;ICFM,MAAM,mBAAmB,SAASC,cAAS,CAAC;IACnD,IAAI,MAAM,MAAM,CAAC,QAAQ,EAAE;IAC3B,QAAQ,OAAO,CAAC,GAAG,CAAC,qDAAqD,CAAC;IAC1E,QAAQ,OAAO;IACf,YAAY,KAAK,EAAE,IAAI;IACvB,YAAY,QAAQ,EAAE,KAAK;IAC3B,YAAY,KAAK,EAAE,GAAG;IACtB,YAAY,SAAS,EAAE,GAAG;IAC1B,YAAY,OAAO,EAAE,qGAAqG;IAC1H,SAAS;IACT,IAAI;IACJ;;;;;;;;;;;;;;;"}

package/ios/Sources/FaceAntiSpoofingPlugin/Align.swift

@@ -0,0 +1,41 @@
+import Foundation
+import UIKit
+
+public class Align {
+    public static func faceAlign(image: UIImage, landmark: [CGPoint]) -> UIImage {
+        let xLeftEye = landmark[0].x
+        let yLeftEye = landmark[0].y
+        let xRightEye = landmark[1].x
+        let yRightEye = landmark[1].y
+
+        let dx = xRightEye - xLeftEye
+        let dy = yRightEye - yLeftEye
+        let angle = atan2(dy, dx) * 180.0 / .pi
+
+        let rotatedImage = image.rotated(by: -angle)
+
+        return rotatedImage
+    }
+}
+
+extension UIImage {
+    func rotated(by degrees: CGFloat) -> UIImage {
+        let radians = degrees * .pi / 180.0
+
+        let rotatedSize = CGRect(origin: .zero, size: size)
+            .applying(CGAffineTransform(rotationAngle: radians))
+            .integral.size
+
+        UIGraphicsBeginImageContext(rotatedSize)
+        defer { UIGraphicsEndImageContext() }
+
+        if let context = UIGraphicsGetCurrentContext() {
+            let origin = CGPoint(x: rotatedSize.width / 2.0, y: rotatedSize.height / 2.0)
+            context.translateBy(x: origin.x, y: origin.y)
+            context.rotate(by: radians)
+            draw(in: CGRect(x: -size.width / 2.0, y: -size.height / 2.0, width: size.width, height: size.height))
+        }
+
+        return UIGraphicsGetImageFromCurrentImageContext() ?? self
+    }
+}

package/ios/Sources/FaceAntiSpoofingPlugin/Box.swift

@@ -0,0 +1,70 @@
+import Foundation
+import UIKit
+
+public class Box {
+    public var box = [Int](repeating: 0, count: 4)
+    public var score: Float = 0
+    public var bbr = [Float](repeating: 0, count: 4)
+    public var deleted = false
+    public var landmark = [CGPoint](repeating: CGPoint.zero, count: 5)
+
+    public func left() -> Int {
+        return box[0]
+    }
+
+    public func right() -> Int {
+        return box[2]
+    }
+
+    public func top() -> Int {
+        return box[1]
+    }
+
+    public func bottom() -> Int {
+        return box[3]
+    }
+
+    public func width() -> Int {
+        return box[2] - box[0] + 1
+    }
+
+    public func height() -> Int {
+        return box[3] - box[1] + 1
+    }
+
+    public func transform2Rect() -> CGRect {
+        return CGRect(x: box[0], y: box[1], width: width(), height: height())
+    }
+
+    public func area() -> Int {
+        return width() * height()
+    }
+
+    public func calibrate() {
+        let w = width()
+        let h = height()
+        box[0] = Int(round(Double(box[0] + Int(bbr[0] * Float(w)))))
+        box[1] = Int(round(Double(box[1] + Int(bbr[1] * Float(h)))))
+        box[2] = Int(round(Double(box[2] + Int(bbr[2] * Float(w)))))
+        box[3] = Int(round(Double(box[3] + Int(bbr[3] * Float(h)))))
+    }
+
+    public func toSquareShape() {
+        let w = width()
+        let h = height()
+        let maxSide = max(w, h)
+        box[2] = box[0] + maxSide - 1
+        box[3] = box[1] + maxSide - 1
+    }
+
+    public func limitSquare(w: Int, h: Int) {
+        if box[0] < 0 { box[0] = 0 }
+        if box[1] < 0 { box[1] = 0 }
+        if box[2] >= w { box[2] = w - 1 }
+        if box[3] >= h { box[3] = h - 1 }
+    }
+
+    public func transbound(w: Int, h: Int) -> Bool {
+        return box[0] < 0 || box[1] < 0 || box[2] >= w || box[3] >= h
+    }
+}

package/ios/Sources/FaceAntiSpoofingPlugin/FaceAntiSpoofing.swift

@@ -0,0 +1,105 @@
+import Foundation
+import UIKit
+import TensorFlowLite
+
+public class FaceAntiSpoofing {
+    private static let modelFileName = "FaceAntiSpoofing"
+    private static let modelFileType = "tflite"
+    private static let imageWidth = 256
+    private static let imageHeight = 256
+    private static let laplaceThreshold = 50
+
+    public static let threshold: Float = 0.5
+    public static let laplacianThreshold = 0
+
+    private var interpreter: Interpreter?
+
+    public init() throws {
+        let modelPath = Tools.filePathForResourceName(name: modelFileName, extension: modelFileType)
+        var options = InterpreterOptions()
+        options.numberOfThreads = 4
+        interpreter = try Interpreter(modelPath: modelPath, options: options)
+        try interpreter?.allocateTensors()
+    }
+
+    public func antiSpoofing(image: UIImage) -> Float {
+        guard let interpreter = interpreter else {
+            return 0
+        }
+
+        let size = CGSize(width: CGFloat(Self.imageWidth), height: CGFloat(Self.imageHeight))
+        guard let imageScale = Tools.scaleImage(image: image, toSize: size),
+              let data = processData(image: imageScale) else {
+            return 0
+        }
+
+        do {
+            try interpreter.copy(data, toInputAt: 0)
+            try interpreter.invoke()
+
+            let clss_pred = try interpreter.output(at: 0) as [Float]
+            let leaf_node_mask = try interpreter.output(at: 1) as [Float]
+
+            var score: Float = 0
+            for i in 0..<8 {
+                score += abs(clss_pred[i]) * leaf_node_mask[i]
+            }
+
+            return score
+        } catch {
+            print("Error running inference: \(error)")
+            return 0
+        }
+    }
+
+    private func processData(image: UIImage) -> Data? {
+        guard let image_data = Tools.convertUIImageToBitmapRGBA8(image: image) else {
+            return nil
+        }
+
+        let input_std: Float = 255.0
+        var floats = [Float](repeating: 0, count: Self.imageWidth * Self.imageHeight * 3)
+
+        var k = 0
+        let size = Self.imageWidth * Self.imageHeight * 4
+        for j in 0..<size {
+            if j % 4 == 3 {
+                continue
+            }
+            floats[k] = Float(image_data[j]) / input_std
+            k += 1
+        }
+        image_data.deallocate()
+
+        return Data(bytes: floats, count: MemoryLayout<Float>.stride * floats.count)
+    }
+
+    public func laplacian(image: UIImage) -> Int {
+        let size = CGSize(width: CGFloat(Self.imageWidth), height: CGFloat(Self.imageHeight))
+        guard let imageScale = Tools.scaleImage(image: image, toSize: size),
+              let image_data = Tools.convertUIImageToBitmapGray(image: imageScale) else {
+            return 0
+        }
+
+        let laplace: [[Int]] = [[0, 1, 0], [1, -4, 1], [0, 1, 0]]
+        let laplaceSize = 3
+
+        var score = 0
+        for x in 0..<(Self.imageHeight - laplaceSize + 1) {
+            for y in 0..<(Self.imageWidth - laplaceSize + 1) {
+                var result = 0
+                for i in 0..<laplaceSize {
+                    for j in 0..<laplaceSize {
+                        result += (Int(image_data[(x + i) * Self.imageWidth + y + j]) & 0xFF) * laplace[i][j]
+                    }
+                }
+                if result > Self.laplaceThreshold {
+                    score += 1
+                }
+            }
+        }
+        image_data.deallocate()
+
+        return score
+    }
+}

package/ios/Sources/FaceAntiSpoofingPlugin/FaceAntiSpoofingPlugin.swift

@@ -0,0 +1,166 @@
+import Foundation
+import Capacitor
+import UIKit
+
+/**
+ * Face Anti-Spoofing Plugin for Capacitor
+ * Provides passive liveness detection using TensorFlow Lite
+ */
+@objc(FaceAntiSpoofingPlugin)
+public class FaceAntiSpoofingPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "FaceAntiSpoofingPlugin"
+    public let jsName = "FaceAntiSpoofing"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "detect", returnType: CAPPluginReturnPromise)
+    ]
+
+    private var faceAntiSpoofing: FaceAntiSpoofing?
+    private var mtcnn: MTCNN?
+
+    override public func load() {
+        do {
+            faceAntiSpoofing = try FaceAntiSpoofing()
+            mtcnn = try MTCNN()
+            print("[FaceAntiSpoofing] Models loaded successfully")
+        } catch {
+            print("[FaceAntiSpoofing] Failed to load models: \(error)")
+        }
+    }
+
+    @objc func detect(_ call: CAPPluginCall) {
+        guard let image = call.getString("image"), !image.isEmpty else {
+            call.reject("Image data is required")
+            return
+        }
+
+        guard let fas = faceAntiSpoofing, let mtcnn = mtcnn else {
+            call.reject("Models not loaded. Please ensure the plugin is properly initialized.")
+            return
+        }
+
+        do {
+            guard let uiImage = decodeImage(from: image) else {
+                call.reject("Failed to decode image")
+                return
+            }
+
+            let result = performAntiSpoofing(on: uiImage, fas: fas, mtcnn: mtcnn)
+            call.resolve(resultToJSObject(result))
+        } catch {
+            call.reject("Error during detection: \(error.localizedDescription)")
+        }
+    }
+
+    private func decodeImage(from imageData: String) -> UIImage? {
+        // Check if it's a base64 string with data URI prefix
+        if imageData.hasPrefix("data:image/") {
+            if let commaIndex = imageData.range(of: ",")?.upperBound {
+                let base64String = String(imageData[commaIndex...])
+                if let imageData = Data(base64Encoded: base64String) {
+                    return UIImage(data: imageData)
+                }
+            }
+        } else if imageData.hasPrefix("file://") {
+            let filePath = String(imageData.dropFirst(7))
+            let url = URL(fileURLWithPath: filePath)
+            if let imageData = try? Data(contentsOf: url) {
+                return UIImage(data: imageData)
+            }
+        } else {
+            // Try as raw base64
+            if let imageData = Data(base64Encoded: imageData) {
+                return UIImage(data: imageData)
+            }
+        }
+        return nil
+    }
+
+    private func performAntiSpoofing(on image: UIImage, fas: FaceAntiSpoofing, mtcnn: MTCNN) -> DetectionResult {
+        var result = DetectionResult()
+
+        let boxes = mtcnn.detectFaces(image: image, minFaceSize: image.size.width / 8)
+
+        if boxes.isEmpty {
+            result.error = true
+            result.message = "No faces detected"
+            return result
+        }
+
+        guard let box1 = boxes.first else {
+            result.error = true
+            result.message = "No faces detected"
+            return result
+        }
+
+        let alignedImage = Align.faceAlign(image: image, landmark: box1.landmark)
+        let boxes2 = mtcnn.detectFaces(image: alignedImage, minFaceSize: alignedImage.size.width / 8)
+
+        if boxes2.isEmpty {
+            result.error = true
+            result.message = "No faces detected"
+            return result
+        }
+
+        guard let box2 = boxes2.first else {
+            result.error = true
+            result.message = "No faces detected"
+            return result
+        }
+
+        var box = box2
+        box.toSquareShape()
+        box.limitSquare(w: Int(alignedImage.size.width), h: Int(alignedImage.size.height))
+
+        let rect = box.transform2Rect()
+        guard let croppedImage = Tools.cropImage(image: alignedImage, toRect: rect) else {
+            result.error = true
+            result.message = "Failed to crop image"
+            return result
+        }
+
+        let laplace = fas.laplacian(image: croppedImage)
+
+        if laplace < FaceAntiSpoofing.laplacianThreshold {
+            result.error = false
+            result.score = "\(laplace)"
+            result.threshold = "\(FaceAntiSpoofing.laplacianThreshold)"
+            result.liveness = false
+            result.message = ""
+        } else {
+            let score = fas.antiSpoofing(image: croppedImage)
+            if score < FaceAntiSpoofing.threshold {
+                result.error = false
+                result.score = "\(score)"
+                result.threshold = "\(FaceAntiSpoofing.threshold)"
+                result.liveness = true
+                result.message = ""
+            } else {
+                result.error = false
+                result.score = "\(score)"
+                result.threshold = "\(FaceAntiSpoofing.threshold)"
+                result.liveness = false
+                result.message = "Sorry, we can't find a face or indicate that the photo is real."
+            }
+        }
+
+        return result
+    }
+
+    private func resultToJSObject(_ result: DetectionResult) -> [String: Any] {
+        return [
+            "error": result.error,
+            "liveness": result.liveness,
+            "score": result.score,
+            "threshold": result.threshold,
+            "message": result.message
+        ]
+    }
+
+    private struct DetectionResult {
+        var error = false
+        var liveness = false
+        var score = "0"
+        var threshold = "0"
+        var message = ""
+    }
+}