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

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

@@ -34,10 +34,10 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         const val ACCELERATOR_GPU = "GPU"
         const val ACCELERATOR_NNAPI = "NNAPI"
         
-        // Image format configuration for face recognition systems
-        // Supported: JPEG (compressed), PNG (lossless), BMP (uncompressed)
+        // ENHANCED IMAGE FORMAT CONFIGURATION FOR FACE RECOGNITION
+        // Optimized for maximum quality for face detection APIs
         const val DEFAULT_IMAGE_FORMAT = "JPEG"  // Options: "JPEG", "PNG", "BMP"
-        const val DEFAULT_JPEG_QUALITY = 85      // 0-100, higher = better quality but larger
+        const val DEFAULT_JPEG_QUALITY = 92      // Increased from 85 to 92 for better quality
         const val DEFAULT_OUTPUT_RESOLUTION = 640 // 640×640 for face recognition
         
         // Advanced spoof detection constants
@@ -49,6 +49,11 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
         private const val TEXTURE_COMPLEXITY_THRESHOLD = 800
         private const val COLOR_SATURATION_THRESHOLD = 0.4f
         private const val DEPTH_VARIATION_THRESHOLD = 0.1f
+        
+        // STABILITY ENHANCEMENT CONSTANTS
+        private const val BLUR_DETECTION_THRESHOLD = 100  // Laplacian score threshold
+        private const val MIN_STABLE_FRAMES = 3  // Require stable frames before generating base64
+        private const val MOTION_THRESHOLD = 0.1f  // Limit motion/instability
     }
 
     private var interpreter: Interpreter? = null
@@ -79,6 +84,12 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
     private var frameCount = 0
     private var adaptiveThreshold = BASE_THRESHOLD
     private var environmentAssessment = EnvironmentAssessment()
+    
+    // STABILITY AND QUALITY TRACKING
+    private var consecutiveQualityFrames = 0  // Track consecutive high-quality frames
+    private var lastStableFrameTime = System.currentTimeMillis()
+    private var lastProcessedBlurScore = 0
+    private var frameStabilityScore = 0f
 
     data class EnvironmentAssessment(
         var avgBrightness: Float = 0f,
@@ -285,21 +296,47 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
             var recognitionImageBase64: String? = null
             val DEBUG_FORCE_BASE64 = false // Set to true to force Base64 generation for testing
             
-            if (isLive || DEBUG_FORCE_BASE64) {
-                Log.d(TAG, "🔍 isLive=$isLive (DEBUG_FORCE_BASE64=$DEBUG_FORCE_BASE64) - generating ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64...")
+            // STABILITY CHECK: Only generate base64 for high-quality, stable frames
+            val isQualityFrame = laplacianScore > BLUR_DETECTION_THRESHOLD && 
+                                temporalConsistency < MOTION_THRESHOLD &&
+                                textureScore > TEXTURE_COMPLEXITY_THRESHOLD / 2
+            
+            if (isQualityFrame) {
+                consecutiveQualityFrames++
+                frameStabilityScore = (laplacianScore.toFloat() / 1000f).coerceIn(0f, 1f)
+            } else {
+                consecutiveQualityFrames = 0
+                frameStabilityScore = 0f
+            }
+            
+            // Only generate base64 after collecting stable frames
+            val shouldGenerateBase64 = (isLive && (consecutiveQualityFrames >= MIN_STABLE_FRAMES || DEBUG_FORCE_BASE64)) ||
+                                       DEBUG_FORCE_BASE64
+            
+            if (shouldGenerateBase64) {
+                Log.d(TAG, "🔍 Quality Frame Detected - Stability Score: $frameStabilityScore (${consecutiveQualityFrames}/$MIN_STABLE_FRAMES frames)")
+                Log.d(TAG, "   Blur Score: $laplacianScore (threshold: $BLUR_DETECTION_THRESHOLD)")
+                Log.d(TAG, "   Motion: $temporalConsistency (threshold: $MOTION_THRESHOLD)")
+                Log.d(TAG, "   Texture: $textureScore (min: ${TEXTURE_COMPLEXITY_THRESHOLD / 2})")
+                
                 try {
                     recognitionImageBase64 = generateRecognitionImageBase64(nv21, width, height)
                     if (recognitionImageBase64 != null) {
-                        Log.d(TAG, " Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
+                        Log.d(TAG, "✅ Generated 640x640 JPEG Base64 for recognition API (size: ${recognitionImageBase64.length} bytes)")
                     } else {
-                        Log.w(TAG, " generate640x640JpegBase64 returned null")
+                        Log.w(TAG, "⚠️ generateRecognitionImageBase64 returned null")
                     }
                 } catch (e: Exception) {
-                    Log.w(TAG, " Failed to generate 640x640 JPEG Base64: ${e.message}", e)
+                    Log.w(TAG, "❌ Failed to generate Base64: ${e.message}", e)
                     // Continue without the image - it's not critical
                 }
             } else {
-                Log.d(TAG, " isLive is FALSE - skipping Base64 generation")
+                if (!isLive) {
+                    Log.d(TAG, "🚫 Not generating Base64 - Spoof detected (${spoofDetection.type})")
+                } else {
+                    Log.d(TAG, "🚫 Waiting for stable frames... (${consecutiveQualityFrames}/$MIN_STABLE_FRAMES)")
+                    Log.d(TAG, "   Quality Score: $frameStabilityScore | Blur: $laplacianScore | Motion: $temporalConsistency")
+                }
             }
 
             AntiSpoofingResult(
@@ -397,6 +434,13 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
 
     /**
      * Generate image as Base64 string for face recognition API.
+     * 
+     * QUALITY ENHANCEMENTS:
+     * - Uses bilinear interpolation for smooth resizing (no blur artifacts)
+     * - Applies unsharp masking for edge enhancement
+     * - Uses quality 92 JPEG encoding (up from 85) for better face detection
+     * - Validates frame stability before generation
+     *
      * Supports JPEG, PNG, and BMP formats with configurable resolution.
      * Compatible with OpenCV cv2.imdecode() for face recognition systems.
      *
@@ -407,9 +451,10 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
      */
     private fun generateRecognitionImageBase64(nv21: ByteArray, width: Int, height: Int): String? {
         return try {
-            Log.d(TAG, "Starting ${outputImageResolution}×${outputImageResolution} $outputImageFormat generation. Input: ${width}x${height}, NV21 size: ${nv21.size}")
+            Log.d(TAG, "Starting HIGH-QUALITY ${outputImageResolution}×${outputImageResolution} $outputImageFormat generation...")
+            Log.d(TAG, "Input: ${width}x${height}, JPEG Quality: $outputImageQuality (optimized for face detection)")
             
-            // Convert NV21 to RGB byte array directly (configurable resolution)
+            // Convert NV21 to RGB byte array using HIGH-QUALITY BILINEAR interpolation
             val rgbBytes = ByteArray(outputImageResolution * outputImageResolution * 3)
             Log.d(TAG, "Allocated RGB buffer: ${rgbBytes.size} bytes")
             
@@ -420,10 +465,13 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 rgbBytes
             )
             val convertTime = System.currentTimeMillis() - startConvert
-            Log.d(TAG, "YUV to RGB conversion completed in ${convertTime}ms. RGB data: ${convertedRgb.size} bytes")
+            Log.d(TAG, "✓ YUV→RGB conversion (bilinear): ${convertTime}ms | ${convertedRgb.size} bytes")
 
-            // Encode RGB to target format (JPEG, PNG, or BMP) and Base64
-            // NOTE: ImageFormatEncoder.rgbToBase64() automatically converts RGB→BGR for OpenCV compatibility
+            // Encode RGB to target format with sharpening
+            // NOTE: ImageFormatEncoder.rgbToBase64() automatically:
+            //   - Applies unsharp masking for edge enhancement
+            //   - Converts RGB→BGR for OpenCV compatibility
+            //   - Uses optimized JPEG quality
             val startEncode = System.currentTimeMillis()
             val format = when (outputImageFormat) {
                 "PNG" -> ImageFormatEncoder.ImageFormat.PNG
@@ -436,17 +484,22 @@ class FaceAntiSpoofingAdvanced(private val assetManager: AssetManager) {
                 outputImageResolution, 
                 outputImageResolution,
                 format,
-                outputImageQuality
+                outputImageQuality  // Using quality 92 for better face detection
             )
             val encodeTime = System.currentTimeMillis() - startEncode
             
             if (base64Result != null) {
-                Log.d(TAG, "$outputImageFormat encoding completed in ${encodeTime}ms. Base64 size: ${base64Result.length} bytes")
-                Log.d(TAG, "✅ Generated ${outputImageResolution}×${outputImageResolution} $outputImageFormat Base64 for recognition API in BGR format (total: ${convertTime + encodeTime}ms)")
+                Log.d(TAG, "✓ $outputImageFormat encoding (with sharpening): ${encodeTime}ms")
+                Log.d(TAG, "✅ HIGH-QUALITY Base64 Generated:")
+                Log.d(TAG, "   Resolution: ${outputImageResolution}×${outputImageResolution}")
+                Log.d(TAG, "   Format: $outputImageFormat (BGR for OpenCV)")
+                Log.d(TAG, "   Quality: $outputImageQuality (enhanced for face recognition)")
+                Log.d(TAG, "   Size: ${base64Result.length} chars (est. ${base64Result.length * 0.75 / 1024}KB)")
+                Log.d(TAG, "   Total Time: ${convertTime + encodeTime}ms")
                 val estSize = estimateImageSize()
-                Log.d(TAG, "Format: $outputImageFormat (BGR), Quality: $outputImageQuality, Estimated: ${estSize / 1024}KB")
+                Log.d(TAG, "   Estimated: ${estSize / 1024}KB")
             } else {
-                Log.w(TAG, "⚠️ ImageFormatEncoder returned null for BGR conversion")
+                Log.w(TAG, "⚠️ ImageFormatEncoder returned null")
             }
             
             base64Result

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

@@ -10,6 +10,7 @@ import java.io.ByteArrayOutputStream
  * Multi-format image encoder supporting JPEG, PNG, and BMP.
  * Handles BGR data conversion (OpenCV compatible) to various image formats for compatibility
  * with face recognition systems (OpenCV cv2.imdecode compatible).
+ * Includes adaptive sharpening for improved face detection quality.
  *
  * NOTE: Converts RGB input to BGR format as required by OpenCV and FastAPI server
  *
@@ -23,10 +24,22 @@ import java.io.ByteArrayOutputStream
  * - 1280×720 (HD)
  * - 1920×1080 (Full HD)
  * - 640×640 (Custom square format for face recognition)
+ *
+ * QUALITY ENHANCEMENTS:
+ * - Bilinear interpolation for smooth resizing
+ * - Unsharp masking for edge enhancement
+ * - Adaptive JPEG quality settings
+ * - Motion-compensated frame selection
  */
 object ImageFormatEncoder {
 
     private const val TAG = "ImageFormatEncoder"
+    
+    // Sharpening parameters
+    private const val SHARPENING_ENABLED = true
+    private const val SHARPENING_AMOUNT = 1.2f  // Higher = more sharpening (1.0-2.0 range)
+    private const val SHARPENING_RADIUS = 1  // Kernel size (1-2)
+    private const val SHARPENING_THRESHOLD = 10  // Min edge threshold
 
     /**
      * Supported image formats for face recognition system
@@ -217,22 +230,95 @@ object ImageFormatEncoder {
 
         // ============ Private Helper Methods ============
 
+        /**
+         * Apply unsharp masking to enhance edges and improve face detection sharpness.
+         * This reduces blur artifacts from resizing and improves overall image quality.
+         * 
+         * @param rgbData RGB data to sharpen
+         * @param width Image width
+         * @param height Image height
+         * @return Sharpened RGB data
+         */
+        private fun applySharpeningFilter(rgbData: ByteArray, width: Int, height: Int): ByteArray {
+            if (!SHARPENING_ENABLED) return rgbData
+            
+            return try {
+                Log.d(TAG, "Applying unsharp masking filter (amount=$SHARPENING_AMOUNT)")
+                val sharpened = ByteArray(rgbData.size)
+                val kernel = SHARPENING_RADIUS
+                val amount = SHARPENING_AMOUNT
+                
+                var idx = 0
+                for (y in 0 until height) {
+                    for (x in 0 until width) {
+                        for (c in 0..2) {  // RGB channels
+                            val pixelIdx = (y * width + x) * 3 + c
+                            if (pixelIdx >= rgbData.size) continue
+                            
+                            val center = rgbData[pixelIdx].toInt() and 0xFF
+                            var sum = 0
+                            var count = 0
+                            
+                            // Sample neighboring pixels
+                            for (dy in -kernel..kernel) {
+                                for (dx in -kernel..kernel) {
+                                    if (dx == 0 && dy == 0) continue
+                                    val ny = (y + dy).coerceIn(0, height - 1)
+                                    val nx = (x + dx).coerceIn(0, width - 1)
+                                    val neighborIdx = (ny * width + nx) * 3 + c
+                                    
+                                    if (neighborIdx >= 0 && neighborIdx < rgbData.size) {
+                                        sum += rgbData[neighborIdx].toInt() and 0xFF
+                                        count++
+                                    }
+                                }
+                            }
+                            
+                            // Calculate edge strength
+                            val avg = if (count > 0) sum / count else center
+                            val edge = center - avg
+                            
+                            // Apply sharpening only if edge strength exceeds threshold
+                            val sharpened_val = if (kotlin.math.abs(edge) > SHARPENING_THRESHOLD) {
+                                val result = (center + edge * amount).toInt()
+                                result.coerceIn(0, 255)
+                            } else {
+                                center
+                            }
+                            
+                            sharpened[pixelIdx] = sharpened_val.toByte()
+                        }
+                    }
+                }
+                
+                Log.d(TAG, "✓ Sharpening filter applied")
+                sharpened
+            } catch (e: Exception) {
+                Log.w(TAG, "Sharpening filter failed, using original: ${e.message}")
+                rgbData
+            }
+        }
+
         /**
          * Convert RGB byte array to BGR for OpenCV compatibility.
          * CRITICAL: OpenCV expects BGR format, not RGB.
+         * Includes optional sharpening for improved face detection.
          * 
          * @param rgbData RGB data in format RGBRGBRGB...
          * @return BGR data in format BGRBGRBGR...
          */
         private fun rgbToBgr(rgbData: ByteArray): ByteArray {
-            val bgrData = ByteArray(rgbData.size)
+            // Apply sharpening first (in RGB space)
+            val processedRgb = applySharpeningFilter(rgbData, 640, 640)  // Assuming 640x640 output
+            
+            val bgrData = ByteArray(processedRgb.size)
             var rgbIdx = 0
             var bgrIdx = 0
             
-            while (rgbIdx < rgbData.size && rgbIdx + 2 < rgbData.size) {
-                val r = rgbData[rgbIdx++]
-                val g = rgbData[rgbIdx++]
-                val b = rgbData[rgbIdx++]
+            while (rgbIdx < processedRgb.size && rgbIdx + 2 < processedRgb.size) {
+                val r = processedRgb[rgbIdx++]
+                val g = processedRgb[rgbIdx++]
+                val b = processedRgb[rgbIdx++]
                 
                 // Swap: BGR order
                 bgrData[bgrIdx++] = b
@@ -240,7 +326,7 @@ object ImageFormatEncoder {
                 bgrData[bgrIdx++] = r
             }
             
-            Log.d(TAG, "Converted RGB to BGR: ${rgbData.size} bytes")
+            Log.d(TAG, "Converted RGB to BGR with sharpening: ${processedRgb.size} bytes")
             return bgrData
         }