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

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

@@ -1,516 +0,0 @@
-package com.faceantispoof
-
-import android.graphics.Bitmap
-import android.graphics.Bitmap.CompressFormat
-import android.util.Base64
-import android.util.Log
-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
- *
- * Supported formats:
- * - JPEG: Compressed, good for network transmission (~80-100 KB at quality 85)
- * - PNG: Lossless, larger file size (~200-300 KB)
- * - BMP: Raw uncompressed, largest size (~2-3 MB for 640×640)
- *
- * Optimized for common resolutions:
- * - 640×480 (VGA)
- * - 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
-     */
-    enum class ImageFormat(val compressFormat: CompressFormat, val mimeType: String) {
-            JPEG(CompressFormat.JPEG, "image/jpeg"),
-            PNG(CompressFormat.PNG, "image/png"),
-            BMP(CompressFormat.WEBP, "image/bmp")  // Android uses WebP as fallback for BMP
-        }
-
-        /**
-         * Convert RGB data to BGR format (OpenCV compatible) and encode to specified image format.
-         * Returns Base64 string compatible with FastAPI server.
-         *
-         * IMPORTANT: This method performs RGB→BGR conversion required by OpenCV cv2.imdecode()
-         *
-         * @param rgbData RGB data as byte array (format: RGBRGBRGB..., 3 channels)
-         * @param width Image width (pixels)
-         * @param height Image height (pixels)
-         * @param format Target image format (JPEG, PNG, BMP)
-         * @param quality Compression quality for JPEG (0-100), ignored for PNG/BMP
-         * @return Base64 encoded image string in BGR color space, or null if encoding fails
-         */
-        fun rgbToBase64(
-            rgbData: ByteArray,
-            width: Int,
-            height: Int,
-            format: ImageFormat = ImageFormat.JPEG,
-            quality: Int = 85
-        ): String? {
-            return try {
-                validateImageDimensions(width, height)
-                validateRgbData(rgbData, width, height)
-
-                // CRITICAL: Convert RGB to BGR for OpenCV compatibility
-                val bgrData = rgbToBgr(rgbData)
-
-                val imageBytes = bgrToImageBytes(bgrData, width, height, format, quality)
-                    ?: return null
-
-                Base64.encodeToString(imageBytes, Base64.NO_WRAP)
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB to BGR ${format.name} Base64: ${e.message}", e)
-                null
-            }
-        }
-
-        /**
-         * Convert RGB float array (normalized 0-1) to image format and return as Base64.
-         * Performs RGB→BGR conversion for OpenCV compatibility.
-         * Each pixel is stored as 3 floats (R, G, B).
-         *
-         * @param rgbFloats RGB data as float array (normalized to 0-1)
-         * @param width Image width
-         * @param height Image height
-         * @param format Target image format
-         * @param quality Compression quality for JPEG
-         * @return Base64 encoded image string in BGR format
-         */
-        fun rgbFloatToBase64(
-            rgbFloats: FloatArray,
-            width: Int,
-            height: Int,
-            format: ImageFormat = ImageFormat.JPEG,
-            quality: Int = 85
-        ): String? {
-            return try {
-                validateImageDimensions(width, height)
-
-                if (rgbFloats.isEmpty()) {
-                    Log.e(TAG, "RGB float array is empty")
-                    return null
-                }
-
-                val expectedSize = width * height * 3
-                if (rgbFloats.size < expectedSize) {
-                    Log.e(TAG, "RGB float array too small: expected $expectedSize, got ${rgbFloats.size}")
-                    return null
-                }
-
-                // Convert float array (normalized 0-1) to byte array (0-255)
-                val rgbBytes = ByteArray(expectedSize)
-                var idx = 0
-                for (i in 0 until expectedSize) {
-                    if (idx >= rgbFloats.size) {
-                        Log.e(TAG, "Float array index out of bounds at $idx")
-                        return null
-                    }
-                    val floatVal = rgbFloats[idx++].coerceIn(0f, 1f)
-                    rgbBytes[i] = (floatVal * 255f).toInt().coerceIn(0, 255).toByte()
-                }
-
-                rgbToBase64(rgbBytes, width, height, format, quality)
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB float to BGR ${format.name} Base64: ${e.message}", e)
-                null
-            }
-        }
-
-        /**
-         * Convert RGB data to raw image bytes (not Base64).
-         * Performs RGB→BGR conversion for OpenCV compatibility.
-         *
-         * @param rgbData RGB data as byte array
-         * @param width Image width
-         * @param height Image height
-         * @param format Target image format
-         * @param quality Compression quality for JPEG
-         * @return Raw image bytes in BGR format, or null if encoding fails
-         */
-        fun rgbToImageBytes(
-            rgbData: ByteArray,
-            width: Int,
-            height: Int,
-            format: ImageFormat = ImageFormat.JPEG,
-            quality: Int = 85
-        ): ByteArray? {
-            return try {
-                validateImageDimensions(width, height)
-                validateRgbData(rgbData, width, height)
-
-                // CRITICAL: Convert RGB to BGR for OpenCV compatibility
-                val bgrData = rgbToBgr(rgbData)
-
-                bgrToImageBytes(bgrData, width, height, format, quality)
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert RGB to BGR ${format.name} bytes: ${e.message}", e)
-                null
-            }
-        }
-
-        /**
-         * Get optimal image format based on use case.
-         * Returns format recommendation for face recognition systems.
-         *
-         * @param useCase One of: "network" (JPEG), "storage" (PNG), "opencv" (JPEG)
-         * @return Recommended ImageFormat
-         */
-        fun getOptimalFormat(useCase: String = "network"): ImageFormat {
-            return when (useCase.lowercase()) {
-                "network" -> ImageFormat.JPEG  // Smaller size for transmission
-                "storage" -> ImageFormat.PNG   // Lossless for long-term storage
-                "opencv" -> ImageFormat.JPEG   // OpenCV optimized
-                else -> ImageFormat.JPEG
-            }
-        }
-
-        /**
-         * Get estimated output size for given resolution and format.
-         * Helps with memory allocation and network planning.
-         *
-         * @param width Image width
-         * @param height Image height
-         * @param format Image format
-         * @param quality JPEG quality if applicable
-         * @return Estimated size in bytes
-         */
-        fun estimateOutputSize(
-            width: Int,
-            height: Int,
-            format: ImageFormat = ImageFormat.JPEG,
-            quality: Int = 85
-        ): Long {
-            val pixelCount = width.toLong() * height
-            return when (format) {
-                ImageFormat.JPEG -> {
-                    // Estimated: 0.1 - 0.15 bytes per pixel at quality 85
-                    (pixelCount * 0.12).toLong()
-                }
-                ImageFormat.PNG -> {
-                    // PNG typically 2-4x larger than JPEG
-                    (pixelCount * 0.5).toLong()
-                }
-                ImageFormat.BMP -> {
-                    // BMP uncompressed: 3 bytes per pixel
-                    pixelCount * 3
-                }
-            }
-        }
-
-        /**
-         * Get format information string for logging.
-         */
-        fun getFormatInfo(format: ImageFormat, width: Int, height: Int, quality: Int = 85): String {
-            val estimatedSize = estimateOutputSize(width, height, format, quality)
-            return "${format.name} (${width}×${height}) est. ${estimatedSize / 1024}KB"
-        }
-
-        // ============ 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 {
-            // 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 < processedRgb.size && rgbIdx + 2 < processedRgb.size) {
-                val r = processedRgb[rgbIdx++]
-                val g = processedRgb[rgbIdx++]
-                val b = processedRgb[rgbIdx++]
-                
-                // Swap: BGR order
-                bgrData[bgrIdx++] = b
-                bgrData[bgrIdx++] = g
-                bgrData[bgrIdx++] = r
-            }
-            
-            Log.d(TAG, "Converted RGB to BGR with sharpening: ${processedRgb.size} bytes")
-            return bgrData
-        }
-
-        /**
-         * Convert BGR data to raw image bytes (not Base64).
-         * BGR data is already in OpenCV format.
-         *
-         * @param bgrData BGR data as byte array (already in OpenCV format)
-         * @param width Image width
-         * @param height Image height
-         * @param format Target image format
-         * @param quality Compression quality for JPEG
-         * @return Raw image bytes, or null if encoding fails
-         */
-        private fun bgrToImageBytes(
-            bgrData: ByteArray,
-            width: Int,
-            height: Int,
-            format: ImageFormat = ImageFormat.JPEG,
-            quality: Int = 85
-        ): ByteArray? {
-            return try {
-                validateImageDimensions(width, height)
-                
-                if (bgrData.size < width * height * 3) {
-                    Log.e(TAG, "BGR data too small: expected ${width * height * 3}, got ${bgrData.size}")
-                    return null
-                }
-
-                val bitmap = createBitmapFromBgr(bgrData, width, height)
-                    ?: return null
-                    
-                val imageBytes = try {
-                    when (format) {
-                        ImageFormat.JPEG -> compressBitmapToBytes(bitmap, format, quality)
-                        ImageFormat.PNG -> compressBitmapToBytes(bitmap, format, 100)
-                        ImageFormat.BMP -> compressBitmapToBytes(bitmap, format, 100)
-                    }
-                } catch (e: Exception) {
-                    Log.e(TAG, "Error compressing bitmap: ${e.message}", e)
-                    null
-                } finally {
-                    try {
-                        bitmap.recycle()
-                    } catch (e: Exception) {
-                        Log.w(TAG, "Error recycling bitmap: ${e.message}")
-                    }
-                }
-                
-                imageBytes
-            } catch (e: Exception) {
-                Log.e(TAG, "Failed to convert BGR to ${format.name} bytes: ${e.message}", e)
-                null
-            }
-        }
-
-        /**
-         * Create Bitmap from BGR byte array (OpenCV format).
-         * BGR format: BGRBGRBGR... (3 bytes per pixel, no alpha)
-         */
-        private fun createBitmapFromBgr(bgrData: ByteArray, width: Int, height: Int): Bitmap? {
-            return try {
-                if (bgrData.isEmpty()) {
-                    Log.e(TAG, "BGR data is empty")
-                    return null
-                }
-                if (width <= 0 || height <= 0) {
-                    Log.e(TAG, "Invalid dimensions: width=$width, height=$height")
-                    return null
-                }
-                
-                val expectedSize = width * height * 3
-                if (bgrData.size < expectedSize) {
-                    Log.e(TAG, "BGR data too small: expected at least $expectedSize, got ${bgrData.size}")
-                    return null
-                }
-                
-                // Convert BGR to ARGB for Bitmap (Android uses ARGB_8888)
-                // BGR order: B, G, R
-                val pixels = IntArray(width * height)
-                var bgrIdx = 0
-                for (i in pixels.indices) {
-                    if (bgrIdx + 2 >= bgrData.size) {
-                        Log.e(TAG, "BGR buffer index out of bounds at pixel $i")
-                        return null
-                    }
-                    val b = bgrData[bgrIdx++].toInt() and 0xFF
-                    val g = bgrData[bgrIdx++].toInt() and 0xFF
-                    val r = bgrData[bgrIdx++].toInt() and 0xFF
-                    pixels[i] = 0xFF000000.toInt() or (r shl 16) or (g shl 8) or b  // ARGB
-                }
-                
-                val bitmap = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888)
-                if (bitmap == null) {
-                    Log.e(TAG, "Failed to create bitmap from BGR")
-                    return null
-                }
-                bitmap
-            } catch (e: Exception) {
-                Log.e(TAG, "Error creating bitmap from BGR: ${e.message}", e)
-                null
-            }
-        }
-
-        /**
-         * Create Bitmap from RGB byte array.
-         * RGB format: RGBRGBRGB... (3 bytes per pixel, no alpha)
-         * DEPRECATED: Use createBitmapFromBgr instead for OpenCV compatibility
-         */
-        @Deprecated("Use createBitmapFromBgr for OpenCV compatibility")
-        private fun createBitmapFromRgb(rgbData: ByteArray, width: Int, height: Int): Bitmap? {
-            return try {
-                if (rgbData.isEmpty()) {
-                    Log.e(TAG, "RGB data is empty")
-                    return null
-                }
-                if (width <= 0 || height <= 0) {
-                    Log.e(TAG, "Invalid dimensions: width=$width, height=$height")
-                    return null
-                }
-                
-                val expectedSize = width * height * 3
-                if (rgbData.size < expectedSize) {
-                    Log.e(TAG, "RGB data too small: expected at least $expectedSize, got ${rgbData.size}")
-                    return null
-                }
-                
-                // Convert RGB to BGR first, then to ARGB for Bitmap
-                val bgrData = rgbToBgr(rgbData)
-                createBitmapFromBgr(bgrData, width, height)
-            } catch (e: Exception) {
-                Log.e(TAG, "Error creating bitmap from RGB: ${e.message}", e)
-                null
-            }
-        }
-
-        /**
-         * Compress Bitmap to specified format bytes.
-         */
-        private fun compressBitmapToBytes(
-            bitmap: Bitmap,
-            format: ImageFormat,
-            quality: Int
-        ): ByteArray {
-            return try {
-                if (bitmap.width <= 0 || bitmap.height <= 0) {
-                    throw IllegalArgumentException("Invalid bitmap dimensions: ${bitmap.width}×${bitmap.height}")
-                }
-                
-                val outputStream = ByteArrayOutputStream()
-                val compressed = bitmap.compress(format.compressFormat, quality, outputStream)
-                
-                if (!compressed) {
-                    Log.w(TAG, "Bitmap compression returned false for ${format.name}")
-                }
-                
-                val bytes = outputStream.toByteArray()
-                if (bytes.isEmpty()) {
-                    Log.w(TAG, "Compressed image bytes are empty")
-                }
-                
-                bytes
-            } catch (e: Exception) {
-                Log.e(TAG, "Error compressing bitmap: ${e.message}", e)
-                ByteArray(0)
-            }
-        }
-
-        /**
-         * Validate image dimensions are within reasonable bounds.
-         */
-        private fun validateImageDimensions(width: Int, height: Int) {
-            require(width > 0 && width <= 4096) { "Image width must be 1-4096 pixels, got $width" }
-            require(height > 0 && height <= 4096) { "Image height must be 1-4096 pixels, got $height" }
-        }
-
-        /**
-         * Validate RGB data buffer is correct size.
-         * RGB format requires exactly width * height * 3 bytes
-         */
-        private fun validateRgbData(rgbData: ByteArray, width: Int, height: Int) {
-            val expectedSize = width * height * 3
-            require(rgbData.size >= expectedSize) {
-                "RGB data size mismatch: expected $expectedSize bytes for ${width}×${height}, got ${rgbData.size}"
-            }
-        }
-}