react-native-vision-camera-spoof-detector 1.1.15 → 1.1.16

package/android/src/main/java/com/faceantispoof/FaceAntiSpoofingAdvanced.kt

@@ -184,6 +184,49 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    fun advancedAntiSpoofingRGBA(rgba: ByteArray, width: Int, height: Int): AntiSpoofingResult {
+        if (!isInitialized) {
+            return AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+
+        return try {
+            val nnScore = neuralNetworkAntiSpoofingRGBA(rgba, width, height).getOrThrow()
+            val laplacianScore = laplacianFromRgba(rgba, width, height).getOrThrow()
+            val isLive = nnScore < BASE_THRESHOLD && laplacianScore > LAPLACIAN_THRESHOLD
+            val combinedScore = calculateCombinedScore(nnScore, laplacianScore)
+            val confidence = calculateConfidence(nnScore, laplacianScore)
+
+            AntiSpoofingResult(
+                neuralNetworkScore = nnScore,
+                laplacianScore = laplacianScore,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = combinedScore,
+                confidence = confidence
+            )
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in advancedAntiSpoofingRGBA", e)
+            AntiSpoofingResult(
+                neuralNetworkScore = 0f,
+                laplacianScore = 0,
+                textureComplexity = 0,
+                temporalConsistency = 0f,
+                colorSaturation = 0f,
+                combinedScore = 0f,
+                confidence = 0f
+            )
+        }
+    }
+
     // FROM WORKING VERSION: neuralNetworkAntiSpoofing with Bitmap
     private fun neuralNetworkAntiSpoofing(bitmap: Bitmap): Result<Float> {
         return try {
@@ -216,6 +259,29 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    private fun neuralNetworkAntiSpoofingRGBA(rgba: ByteArray, width: Int, height: Int): Result<Float> {
+        return try {
+            val img = normalizeRgbaImage(rgba, width, height, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
+            val input = arrayOf(img)
+
+            clssPred[0].fill(0f)
+            leafNodeMask[0].fill(0f)
+
+            outputs[outputIndex0] = clssPred
+            outputs[outputIndex1] = leafNodeMask
+
+            interpreter!!.runForMultipleInputsOutputs(arrayOf(input), outputs)
+
+            Log.i(TAG, "clss_pred: [${clssPred[0].joinToString()}]")
+            Log.i(TAG, "leaf_node_mask: [${leafNodeMask[0].joinToString()}]")
+
+            Result.success(leafScore1(clssPred, leafNodeMask))
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in neuralNetworkAntiSpoofingRGBA", e)
+            Result.failure(e)
+        }
+    }
+
     // FROM WORKING VERSION: leafScore1
     private fun leafScore1(clssPred: Array<FloatArray>, leafNodeMask: Array<FloatArray>): Float {
         var score = 0f
@@ -247,6 +313,33 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return floatValues
     }
 
+    private fun normalizeRgbaImage(
+        rgba: ByteArray,
+        srcWidth: Int,
+        srcHeight: Int,
+        targetWidth: Int,
+        targetHeight: Int
+    ): Array<Array<FloatArray>> {
+        val floatValues = Array(targetHeight) { Array(targetWidth) { FloatArray(3) } }
+        val scaleX = srcWidth.toFloat() / targetWidth
+        val scaleY = srcHeight.toFloat() / targetHeight
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * scaleY).toInt().coerceIn(0, srcHeight - 1)
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * scaleX).toInt().coerceIn(0, srcWidth - 1)
+                val srcIndex = (srcY * srcWidth + srcX) * 4
+
+                val r = (rgba[srcIndex].toInt() and 0xFF) / 255f
+                val g = (rgba[srcIndex + 1].toInt() and 0xFF) / 255f
+                val b = (rgba[srcIndex + 2].toInt() and 0xFF) / 255f
+                floatValues[targetY][targetX] = floatArrayOf(r, g, b)
+            }
+        }
+
+        return floatValues
+    }
+
     // FROM WORKING VERSION: laplacian with Bitmap
     private fun laplacian(bitmap: Bitmap): Result<Int> {
         return try {
@@ -264,6 +357,17 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         }
     }
 
+    private fun laplacianFromRgba(rgba: ByteArray, width: Int, height: Int): Result<Int> {
+        return try {
+            val gray = rgbaToGrayscale(rgba, width, height, INPUT_IMAGE_SIZE, INPUT_IMAGE_SIZE)
+            val score = calculateLaplacianFromGray(gray)
+            Result.success(score)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error in laplacianFromRgba", e)
+            Result.failure(e)
+        }
+    }
+
     // FROM WORKING VERSION: calculateLaplacianScore
     private fun calculateLaplacianScore(bitmap: Bitmap): Int {
         val laplace = arrayOf(
@@ -315,6 +419,58 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return greyImg
     }
 
+    private fun rgbaToGrayscale(
+        rgba: ByteArray,
+        srcWidth: Int,
+        srcHeight: Int,
+        targetWidth: Int,
+        targetHeight: Int
+    ): Array<IntArray> {
+        val gray = Array(targetHeight) { IntArray(targetWidth) }
+        val scaleX = srcWidth.toFloat() / targetWidth
+        val scaleY = srcHeight.toFloat() / targetHeight
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = (targetY * scaleY).toInt().coerceIn(0, srcHeight - 1)
+            for (targetX in 0 until targetWidth) {
+                val srcX = (targetX * scaleX).toInt().coerceIn(0, srcWidth - 1)
+                val srcIndex = (srcY * srcWidth + srcX) * 4
+                val r = rgba[srcIndex].toInt() and 0xFF
+                val g = rgba[srcIndex + 1].toInt() and 0xFF
+                val b = rgba[srcIndex + 2].toInt() and 0xFF
+                gray[targetY][targetX] = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
+            }
+        }
+
+        return gray
+    }
+
+    private fun calculateLaplacianFromGray(img: Array<IntArray>): Int {
+        val laplace = arrayOf(
+            intArrayOf(0, 1, 0),
+            intArrayOf(1, -4, 1),
+            intArrayOf(0, 1, 0)
+        )
+
+        val height = img.size
+        val width = img[0].size
+        var score = 0
+        for (x in 0 until height - laplace.size + 1) {
+            for (y in 0 until width - laplace.size + 1) {
+                var result = 0
+                for (i in 0 until laplace.size) {
+                    for (j in 0 until laplace.size) {
+                        result += img[x + i][y + j] * laplace[i][j]
+                    }
+                }
+                if (result > LAPLACE_THRESHOLD) {
+                    score++
+                }
+            }
+        }
+        return score
+    }
+
     // FROM WORKING VERSION: calculateCombinedScore
     private fun calculateCombinedScore(neuralScore: Float, laplacianScore: Int): Float {
         // Normalize both scores to 0-1 range
@@ -422,6 +578,22 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
     }
 
+    private fun rgbaToBitmap(rgba: ByteArray, width: Int, height: Int): Bitmap {
+        val pixels = IntArray(width * height)
+        var index = 0
+        for (y in 0 until height) {
+            for (x in 0 until width) {
+                val r = rgba[index].toInt() and 0xFF
+                val g = rgba[index + 1].toInt() and 0xFF
+                val b = rgba[index + 2].toInt() and 0xFF
+                val a = rgba[index + 3].toInt() and 0xFF
+                pixels[y * width + x] = (a shl 24) or (r shl 16) or (g shl 8) or b
+                index += 4
+            }
+        }
+        return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
+    }
+
     @Throws(IOException::class)
     private fun loadModelFile(assetManager: AssetManager, modelName: String): MappedByteBuffer {
         return try {

package/android/src/main/java/com/margelo/nitro/camera/spoofdetector/HybridSpoofDetectorOutput.kt

@@ -53,7 +53,7 @@ class HybridSpoofDetectorOutput(
         .build()
     }
     val analysis = ImageAnalysis.Builder()
-      .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_YUV_420_888)
+      .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
       .setOutputImageRotationEnabled(false)
       .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
       .setAllowDroppingLateFrames(true)
@@ -71,16 +71,8 @@ class HybridSpoofDetectorOutput(
       return
     }
     try {
-      val sourcePlanes = image.planes
-      val planes = Array(3) { index ->
-        val buffer = sourcePlanes[index].buffer.duplicate()
-        ByteArray(buffer.remaining()).also(buffer::get)
-      }
-      val rowStrides = IntArray(3) { sourcePlanes[it].rowStride }
-      val pixelStrides = IntArray(3) { sourcePlanes[it].pixelStride.coerceAtLeast(1) }
-      val result = detector.advancedAntiSpoofing(
-        planes, image.width, image.height, rowStrides, pixelStrides
-      )
+      val rgba = extractRgbaBytes(image)
+      val result = detector.advancedAntiSpoofingRGBA(rgba, image.width, image.height)
       val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
         result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
       options.onResult.invoke(
@@ -101,6 +93,51 @@ class HybridSpoofDetectorOutput(
     }
   }
 
+  private fun extractRgbaBytes(image: ImageProxy): ByteArray {
+    val plane = image.planes.firstOrNull() ?: throw IllegalStateException("RGBA image has no planes")
+    val rowStride = plane.rowStride
+    val pixelStride = plane.pixelStride
+    val width = image.width
+    val height = image.height
+    val bytesPerPixel = 4
+    val rowBytes = width * bytesPerPixel
+    val rgba = ByteArray(rowBytes * height)
+    val buffer = plane.buffer.duplicate()
+    buffer.order(java.nio.ByteOrder.nativeOrder())
+
+    for (y in 0 until height) {
+      val srcOffset = y * rowStride
+      val dstOffset = y * rowBytes
+      val copyLength = rowBytes.coerceAtMost(rowStride)
+      buffer.position(srcOffset)
+      val slice = ByteArray(copyLength)
+      buffer.get(slice)
+      System.arraycopy(slice, 0, rgba, dstOffset, copyLength)
+    }
+
+    if (pixelStride != 4) {
+      val packed = ByteArray(width * height * bytesPerPixel)
+      var outputIndex = 0
+      for (y in 0 until height) {
+        val rowOffset = y * rowStride
+        for (x in 0 until width) {
+          val pixelOffset = rowOffset + x * pixelStride
+          val r = buffer.get(pixelOffset).toInt() and 0xFF
+          val g = buffer.get(pixelOffset + 1).toInt() and 0xFF
+          val b = buffer.get(pixelOffset + 2).toInt() and 0xFF
+          val a = buffer.get(pixelOffset + 3).toInt() and 0xFF
+          packed[outputIndex++] = r.toByte()
+          packed[outputIndex++] = g.toByte()
+          packed[outputIndex++] = b.toByte()
+          packed[outputIndex++] = a.toByte()
+        }
+      }
+      return packed
+    }
+
+    return rgba
+  }
+
   override fun dispose() {
     disposed.set(true)
     imageAnalysis?.clearAnalyzer()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.1.15",
+  "version": "1.1.16",
   "description": "High-performance face anti-spoofing and liveness detection module for React Native Vision Camera. Uses TensorFlow Lite with GPU acceleration and optimized YUV processing.",
   "homepage": "https://github.com/dpraful/react-native-vision-camera-spoof-detector",
   "repository": {