react-native-vision-camera-spoof-detector 1.1.20 → 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/android/src/main/java/com/margelo/nitro/camera/spoofdetector/HybridSpoofDetectorOutput.kt

@@ -13,6 +13,9 @@ import com.margelo.nitro.camera.extensions.setAllowDroppingLateFrames
 import com.margelo.nitro.camera.extensions.surfaceRotation
 import com.margelo.nitro.camera.public.NativeCameraOutput
 import com.faceantispoof.FaceAntiSpoofingAdvanced
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -32,10 +35,19 @@ class HybridSpoofDetectorOutput(
   private val executor = Executors.newSingleThreadExecutor()
   private val busy = AtomicBoolean(false)
   private val disposed = AtomicBoolean(false)
+  private val frameCounter = java.util.concurrent.atomic.AtomicInteger(0)
+  private var lastFrameBrightness = 0f
   private val detector = FaceAntiSpoofingAdvanced(
     NitroModules.applicationContext?.assets ?: error("FaceAntiSpoof: no application context")
   )
   private var imageAnalysis: ImageAnalysis? = null
+  private companion object {
+    private const val FRAME_EVALUATION_INTERVAL = 3
+    private const val MIN_FRAME_BRIGHTNESS = 24f
+    private const val MAX_FRAME_BRIGHTNESS = 220f
+    private const val MIN_VARIANCE_FOR_ANALYSIS = 1500f
+    private const val MIN_BRIGHTNESS_DELTA = 8f
+  }
 
   override fun createUseCase(
     mirrorMode: MirrorMode,
@@ -72,6 +84,10 @@ class HybridSpoofDetectorOutput(
     }
     try {
       val rgba = extractRgbaBytes(image)
+      if (!shouldProcessFrame(rgba, image.width, image.height)) {
+        return
+      }
+
       val result = detector.advancedAntiSpoofingRGBA(rgba, image.width, image.height)
       val isLive = result.neuralNetworkScore < FaceAntiSpoofingAdvanced.BASE_THRESHOLD &&
         result.laplacianScore > FaceAntiSpoofingAdvanced.LAPLACIAN_THRESHOLD
@@ -93,6 +109,50 @@ class HybridSpoofDetectorOutput(
     }
   }
 
+  private fun shouldProcessFrame(rgba: ByteArray, width: Int, height: Int): Boolean {
+    val frameIndex = frameCounter.incrementAndGet()
+    if (frameIndex % FRAME_EVALUATION_INTERVAL != 0) {
+      return false
+    }
+
+    val sampleStep = max(1, min(width, height) / 32)
+    var brightnessSum = 0L
+    var brightnessSquaredSum = 0L
+    var sampleCount = 0
+
+    for (y in 0 until height step sampleStep) {
+      val rowOffset = y * width * 4
+      for (x in 0 until width step sampleStep) {
+        val index = rowOffset + x * 4
+        if (index + 2 >= rgba.size) continue
+
+        val r = rgba[index].toInt() and 0xFF
+        val g = rgba[index + 1].toInt() and 0xFF
+        val b = rgba[index + 2].toInt() and 0xFF
+        val luma = (0.299 * r + 0.587 * g + 0.114 * b).toInt()
+
+        brightnessSum += luma.toLong()
+        brightnessSquaredSum += (luma.toLong() * luma.toLong())
+        sampleCount += 1
+      }
+    }
+
+    if (sampleCount == 0) {
+      return false
+    }
+
+    val avgBrightness = brightnessSum.toFloat() / sampleCount
+    val variance = (brightnessSquaredSum.toFloat() / sampleCount) - (avgBrightness * avgBrightness)
+    val brightnessDelta = kotlin.math.abs(avgBrightness - lastFrameBrightness)
+    lastFrameBrightness = avgBrightness
+
+    val brightnessOk = avgBrightness in MIN_FRAME_BRIGHTNESS..MAX_FRAME_BRIGHTNESS
+    val textureOk = variance >= MIN_VARIANCE_FOR_ANALYSIS
+    val motionLikely = brightnessDelta >= MIN_BRIGHTNESS_DELTA || lastFrameBrightness == 0f
+
+    return brightnessOk && textureOk && motionLikely
+  }
+
   private fun extractRgbaBytes(image: ImageProxy): ByteArray {
     val plane = image.planes.firstOrNull() ?: throw IllegalStateException("RGBA image has no planes")
     val rowStride = plane.rowStride

package/package.json

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