react-native-vision-camera-spoof-detector 1.1.21 → 1.1.22

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

@@ -292,29 +292,6 @@ 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)
-        }
-    }
-
     private fun neuralNetworkAntiSpoofingSampled(rgbBuffer: Array<Array<FloatArray>>): Result<Float> {
         return try {
             val input = arrayOf(rgbBuffer)
@@ -363,38 +340,13 @@ 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
-    }
-
     private data class SampledFrame(
         val rgbBuffer: Array<Array<FloatArray>>,
         val grayBuffer: Array<IntArray>
     )
 
+    // Single-pass resize: one source pixel sample writes both the model RGB tensor
+    // and the grayscale buffer used for Laplacian scoring.
     private fun sampleRgbaToModelAndGray(
         rgba: ByteArray,
         srcWidth: Int,
@@ -446,17 +398,6 @@ 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(
@@ -508,32 +449,6 @@ 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),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.1.21",
+  "version": "1.1.22",
   "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": {