react-native-vision-camera-spoof-detector 1.0.8 → 1.0.10

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

@@ -1,15 +1,37 @@
 package com.faceantispoof
 
 import java.nio.ByteBuffer
+import kotlin.math.abs
+import kotlin.math.pow
 
 /**
  * Converts YUV NV21 data directly to normalized RGB float arrays without creating Bitmaps.
- * Supports downsampling/resizing in-place using nearest-neighbor interpolation.
+ * Supports high-quality bilinear interpolation for resizing to minimize blur.
+ * Includes motion/stability detection and frame quality assessment.
  */
 class YuvToFloatArrayConverter {
+    
+    // Motion detection and frame stability
+    private var previousGrayscale: IntArray? = null
+    private var frameMotionScore = 0f
+    private var isFrameStable = false
+    private var consecutiveStableFrames = 0
+    private val STABILITY_THRESHOLD = 0.05f // Lower = more stable frames required
+    private val STABLE_FRAMES_REQUIRED = 3
+    
+    companion object {
+        // Interpolation quality modes
+        const val INTERPOLATION_NEAREST = 0
+        const val INTERPOLATION_BILINEAR = 1
+        const val INTERPOLATION_BICUBIC = 2
+        
+        // Default to bilinear for better quality
+        private val DEFAULT_INTERPOLATION = INTERPOLATION_BILINEAR
+    }
 
     /**
      * Convert NV21 YUV data directly to a normalized RGB float array.
+     * Uses high-quality bilinear interpolation to preserve image sharpness.
      * Output array is [height][width][3] where RGB channels are normalized to [0, 1].
      * @param nv21 NV21 encoded YUV data
      * @param width Original frame width
@@ -25,7 +47,8 @@ class YuvToFloatArrayConverter {
         height: Int,
         targetWidth: Int = width,
         targetHeight: Int = height,
-        outputRgbFloat: FloatArray? = null
+        outputRgbFloat: FloatArray? = null,
+        interpolationMode: Int = DEFAULT_INTERPOLATION
     ): FloatArray {
         if (nv21.isEmpty()) {
             throw IllegalArgumentException("NV21 array is empty")
@@ -49,6 +72,12 @@ class YuvToFloatArrayConverter {
             throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
         }
 
+        // Use bilinear interpolation for high-quality resizing
+        if (interpolationMode == INTERPOLATION_BILINEAR && (width != targetWidth || height != targetHeight)) {
+            return nv21ToRgbFloatArrayBilinear(nv21, width, height, targetWidth, targetHeight, output)
+        }
+
+        // Fallback to nearest neighbor
         var outIdx = 0
 
         for (targetY in 0 until targetHeight) {
@@ -102,6 +131,136 @@ class YuvToFloatArrayConverter {
         return output
     }
 
+    /**
+     * High-quality bilinear interpolation for resizing YUV to RGB.
+     * Significantly better quality than nearest-neighbor, reduces blur artifacts.
+     */
+    private fun nv21ToRgbFloatArrayBilinear(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        targetWidth: Int,
+        targetHeight: Int,
+        output: FloatArray
+    ): FloatArray {
+        val ySize = width * height
+        val uvPixelStride = 2
+        val scaleX = width.toFloat() / targetWidth
+        val scaleY = height.toFloat() / targetHeight
+        
+        var outIdx = 0
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = targetY * scaleY
+            val y1 = srcY.toInt()
+            val y2 = (y1 + 1).coerceAtMost(height - 1)
+            val fracY = srcY - y1
+
+            for (targetX in 0 until targetWidth) {
+                val srcX = targetX * scaleX
+                val x1 = srcX.toInt()
+                val x2 = (x1 + 1).coerceAtMost(width - 1)
+                val fracX = srcX - x1
+
+                // Sample 4 neighboring pixels in YUV space and interpolate
+                val (r, g, b) = bilinearInterpolateYuv(
+                    nv21, width, height, ySize, uvPixelStride,
+                    x1, y1, x2, y2, fracX, fracY
+                )
+
+                if (outIdx + 2 < output.size) {
+                    output[outIdx++] = r / 255f
+                    output[outIdx++] = g / 255f
+                    output[outIdx++] = b / 255f
+                }
+            }
+        }
+
+        return output
+    }
+
+    /**
+     * Bilinear interpolation for YUV pixel sampling.
+     * Returns interpolated RGB values.
+     */
+    private fun bilinearInterpolateYuv(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        ySize: Int,
+        uvPixelStride: Int,
+        x1: Int,
+        y1: Int,
+        x2: Int,
+        y2: Int,
+        fracX: Float,
+        fracY: Float
+    ): Triple<Float, Float, Float> {
+        // Sample all 4 corners
+        val samples = arrayOf(
+            yuvToRgb(nv21, width, ySize, uvPixelStride, x1, y1),
+            yuvToRgb(nv21, width, ySize, uvPixelStride, x2, y1),
+            yuvToRgb(nv21, width, ySize, uvPixelStride, x1, y2),
+            yuvToRgb(nv21, width, ySize, uvPixelStride, x2, y2)
+        )
+
+        // Bilinear interpolation
+        val top = lerp(samples[0], samples[1], fracX)
+        val bottom = lerp(samples[2], samples[3], fracX)
+        return lerp(top, bottom, fracY)
+    }
+
+    /**
+     * Linear interpolation helper.
+     */
+    private fun lerp(a: Triple<Float, Float, Float>, b: Triple<Float, Float, Float>, t: Float): Triple<Float, Float, Float> {
+        return Triple(
+            a.first * (1 - t) + b.first * t,
+            a.second * (1 - t) + b.second * t,
+            a.third * (1 - t) + b.third * t
+        )
+    }
+
+    /**
+     * Convert a single YUV pixel to RGB with optional gamma correction.
+     * Applies sRGB gamma curve to match hardware ISP output.
+     */
+    private fun yuvToRgb(
+        nv21: ByteArray,
+        width: Int,
+        ySize: Int,
+        uvPixelStride: Int,
+        x: Int,
+        y: Int
+    ): Triple<Float, Float, Float> {
+        val yIdx = y * width + x
+        val yVal = nv21[yIdx].toInt() and 0xFF
+
+        val uvIndex = ySize + (y / 2) * width + (x / 2) * uvPixelStride
+        val vVal = nv21[uvIndex].toInt() and 0xFF
+        val uVal = nv21[uvIndex + 1].toInt() and 0xFF
+
+        val yf = yVal.toFloat()
+        val uf = uVal - 128f
+        val vf = vVal - 128f
+
+        val r = (yf + 1.402f * vf).coerceIn(0f, 255f)
+        val g = (yf - 0.34414f * uf - 0.71414f * vf).coerceIn(0f, 255f)
+        val b = (yf + 1.772f * uf).coerceIn(0f, 255f)
+
+        // FIXED: Apply sRGB gamma correction to match hardware ISP
+        // This ensures that colors match hardware-captured JPEGs
+        val rLinear = r / 255f
+        val gLinear = g / 255f
+        val bLinear = b / 255f
+        
+        val rCorrected = applyGammaCorrection(rLinear)
+        val gCorrected = applyGammaCorrection(gLinear)
+        val bCorrected = applyGammaCorrection(bLinear)
+
+        return Triple(rCorrected * 255f, gCorrected * 255f, bCorrected * 255f)
+    }
+
     /**
      * Convert NV21 directly to a flat RGB float buffer (single channel interleaving).
      * @param nv21 NV21 encoded YUV data
@@ -257,6 +416,7 @@ class YuvToFloatArrayConverter {
 
     /**
      * Convert NV21 directly to RGB byte array without float conversion.
+     * Uses high-quality bilinear interpolation for resizing.
      * Optimized for JPEG encoding (where RGB bytes are needed directly).
      * Output format: RGBRGBRGB... (no alpha channel)
      *
@@ -297,6 +457,12 @@ class YuvToFloatArrayConverter {
             throw IllegalArgumentException("NV21 buffer too small: expected at least $minExpectedSize, got ${nv21.size}")
         }
 
+        // Use bilinear interpolation for better quality
+        if (width != targetWidth || height != targetHeight) {
+            return nv21ToRgbByteArrayBilinear(nv21, width, height, targetWidth, targetHeight, output)
+        }
+
+        // Direct copy with nearest neighbor
         var outIdx = 0
 
         for (targetY in 0 until targetHeight) {
@@ -348,4 +514,71 @@ class YuvToFloatArrayConverter {
 
         return output
     }
+
+    /**
+     * High-quality bilinear interpolation for RGB byte array resizing.
+     */
+    private fun nv21ToRgbByteArrayBilinear(
+        nv21: ByteArray,
+        width: Int,
+        height: Int,
+        targetWidth: Int,
+        targetHeight: Int,
+        output: ByteArray
+    ): ByteArray {
+        val ySize = width * height
+        val uvPixelStride = 2
+        val scaleX = width.toFloat() / targetWidth
+        val scaleY = height.toFloat() / targetHeight
+        
+        var outIdx = 0
+
+        for (targetY in 0 until targetHeight) {
+            val srcY = targetY * scaleY
+            val y1 = srcY.toInt()
+            val y2 = (y1 + 1).coerceAtMost(height - 1)
+            val fracY = srcY - y1
+
+            for (targetX in 0 until targetWidth) {
+                val srcX = targetX * scaleX
+                val x1 = srcX.toInt()
+                val x2 = (x1 + 1).coerceAtMost(width - 1)
+                val fracX = srcX - x1
+
+
+                val (r, g, b) = bilinearInterpolateYuv(
+                    nv21, width, height, ySize, uvPixelStride,
+                    x1, y1, x2, y2, fracX, fracY
+                )
+
+                if (outIdx + 2 < output.size) {
+                    output[outIdx++] = r.toInt().toByte()
+                    output[outIdx++] = g.toInt().toByte()
+                    output[outIdx++] = b.toInt().toByte()
+                }
+            }
+        }
+
+        return output
+    }
+
+    /**
+     * Apply sRGB gamma correction to match hardware camera ISP output.
+     * This is CRITICAL for face recognition: hardware cameras apply gamma correction,
+     * but raw YUV conversion doesn't. This function brings the frame processor output
+     * in line with native camera JPEGs.
+     * 
+     * @param linear Linear RGB value in range [0, 1]
+     * @return Gamma-corrected RGB value in range [0, 1]
+     */
+    private fun applyGammaCorrection(linear: Float): Float {
+        return if (linear <= 0.0031308f) {
+            // Linear segment for very dark values
+            linear * 12.92f
+        } else {
+            // Power law segment for normal values
+            // sRGB formula: value^(1/2.4)
+            1.055f * Math.pow(linear.toDouble(), 1.0 / 2.4).toFloat() - 0.055f
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-vision-camera-spoof-detector",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "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/jescon-tech/react-native-vision-camera-spoof-detector",
   "repository": {

package/android/build/intermediates/cxx/Debug/2a1it684/logs/arm64-v8a/generate_cxx_metadata_1041_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 785ms
-    [gap of 26ms]
-  execute-generate-process completed in 812ms
-  [gap of 18ms]
-generate_cxx_metadata completed in 837ms
-

package/android/build/intermediates/cxx/Debug/2a1it684/logs/x86_64/generate_cxx_metadata_1042_timing.txt

@@ -1,9 +0,0 @@
-# C/C++ build system timings
-generate_cxx_metadata
-  execute-generate-process
-    exec-configure 464ms
-    [gap of 23ms]
-  execute-generate-process completed in 489ms
-  [gap of 17ms]
-generate_cxx_metadata completed in 521ms
-