@trustchex/react-native-sdk 1.472.0 → 1.475.1

package/android/build.gradle

@@ -83,9 +83,9 @@ dependencies {
   implementation "androidx.camera:camera-video:1.4.0"
 
   // Google ML Kit dependencies
-  implementation 'com.google.mlkit:text-recognition:16.0.0'
-  implementation 'com.google.mlkit:face-detection:16.1.5'
-  implementation 'com.google.mlkit:barcode-scanning:17.1.0'
+  implementation 'com.google.mlkit:text-recognition:16.0.1'
+  implementation 'com.google.mlkit:face-detection:16.1.7'
+  implementation 'com.google.mlkit:barcode-scanning:17.3.0'
 
   // Google Play Services dependency for Tasks
   implementation 'com.google.android.gms:play-services-tasks:18.2.0'

package/android/src/main/java/com/trustchex/reactnativesdk/camera/TrustchexCameraView.kt

@@ -452,9 +452,20 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
             // Brightness calculation restricted to scanning frame area (between 36% from top and 36% from bottom, 5% margins on sides)
             val averageBrightness = computeYPlaneBrightness(imageProxy, reportedWidth, reportedHeight)
 
-            // Use original inputImage directly for text recognition
-            // ML Kit works best with native camera frames, not processed bitmaps
-            val textInputImage = inputImage
+            // Text recognition: process ONLY the data inside the on-screen scan
+            // frame. We capture the full image but crop to the scan-frame ROI
+            // (top 36% / bottom 36% / 5% side margins — the same rectangle the UI
+            // guide and brightness sampling use) and UPSCALE it before OCR. This
+            // (a) excludes front-of-card text and surrounding noise (screen glare,
+            // IDE/browser chrome) that pollute the MRZ read, and (b) gives ML Kit
+            // more pixels per character — ML Kit needs ≥16px/char, and a full-frame
+            // capture leaves a 30–44-char MRZ line below that floor. Block
+            // coordinates from the ROI pass are mapped back to the full portrait
+            // frame so the JS overlay/filters stay correct.
+            val roi = if (textRecognitionEnabled) {
+                buildScanFrameRoiImage(imageProxy, rotationDegrees, reportedWidth, reportedHeight)
+            } else null
+            val textInputImage = roi?.image ?: inputImage
 
             // Generate JPEG base64 only when JS side explicitly needs the image
             // NOTE: Do NOT auto-generate for face detection - too expensive, causes frame drops
@@ -539,13 +550,23 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
                                 blockMap.putString("text", block.text)
                                 val bb = block.boundingBox
                                 if (bb != null) {
+                                    // When OCR ran on the upscaled scan-frame ROI, map
+                                    // the box back to full portrait-frame coordinates:
+                                    // divide by the ROI upscale, then add the ROI origin.
+                                    val s = roi?.scale ?: 1f
+                                    val ox = roi?.offsetX ?: 0
+                                    val oy = roi?.offsetY ?: 0
+                                    val left = (bb.left / s).toInt() + ox
+                                    val top = (bb.top / s).toInt() + oy
+                                    val w = (bb.width() / s).toInt()
+                                    val h = (bb.height() / s).toInt()
                                     val boxMap = Arguments.createMap()
-                                    boxMap.putInt("x", bb.left)
-                                    boxMap.putInt("y", bb.top)
-                                    boxMap.putInt("width", bb.width())
-                                    boxMap.putInt("height", bb.height())
-                                    boxMap.putInt("boundingCenterX", bb.centerX())
-                                    boxMap.putInt("boundingCenterY", bb.centerY())
+                                    boxMap.putInt("x", left)
+                                    boxMap.putInt("y", top)
+                                    boxMap.putInt("width", w)
+                                    boxMap.putInt("height", h)
+                                    boxMap.putInt("boundingCenterX", left + w / 2)
+                                    boxMap.putInt("boundingCenterY", top + h / 2)
                                     blockMap.putMap("blockFrame", boxMap)
                                 }
                                 blocksArray.pushMap(blockMap)
@@ -1017,6 +1038,123 @@ class TrustchexCameraView(context: ThemedReactContext) : FrameLayout(context) {
         }
     }
 
+    /** A scan-frame ROI prepared for OCR, with the transform back to full-frame coords. */
+    private data class ScanFrameRoi(
+        val image: InputImage,
+        val offsetX: Int,
+        val offsetY: Int,
+        val scale: Float
+    )
+
+    /**
+     * Builds an [InputImage] cropped to the on-screen scan frame (top 36% /
+     * bottom 36% / 5% side margins — the same rectangle the UI guide draws) and
+     * UPSCALED so ML Kit gets more pixels per character. We capture the full frame
+     * but OCR only this region, which removes front-of-card text and surrounding
+     * noise and lifts a dense MRZ line above ML Kit's ≥16px/char floor. Returns
+     * null on any failure so the caller falls back to full-frame OCR.
+     */
+    private fun buildScanFrameRoiImage(
+        imageProxy: ImageProxy,
+        rotationDegrees: Int,
+        portraitWidth: Int,
+        portraitHeight: Int
+    ): ScanFrameRoi? {
+        return try {
+            val full = yuvImageToBitmap(imageProxy, rotationDegrees) ?: return null
+
+            // Scan-frame rectangle in the rotated (portrait) bitmap. Covers the
+            // lower-middle band where the MRZ lands, with generous vertical
+            // tolerance (top 25% → bottom 12%) so the band doesn't have to be
+            // perfectly centered to be OCR'd. Keep it large enough for tolerance
+            // but not the whole frame (front text/glare would creep back in).
+            val scanTopPercent = 0.25
+            val scanBottomPercent = 0.12
+            val scanLeftPercent = 0.04
+            val scanRightPercent = 0.04
+            val left = (full.width * scanLeftPercent).toInt().coerceIn(0, full.width - 1)
+            val right = (full.width * (1.0 - scanRightPercent)).toInt().coerceIn(left + 1, full.width)
+            val top = (full.height * scanTopPercent).toInt().coerceIn(0, full.height - 1)
+            val bottom = (full.height * (1.0 - scanBottomPercent)).toInt().coerceIn(top + 1, full.height)
+            val cropW = right - left
+            val cropH = bottom - top
+            if (cropW < 8 || cropH < 8) {
+                full.recycle()
+                return null
+            }
+
+            val cropped = Bitmap.createBitmap(full, left, top, cropW, cropH)
+            full.recycle()
+
+            // Upscale so a ~30–44-char MRZ line clears the per-character pixel
+            // minimum. Cap the long edge to keep OCR latency bounded.
+            val maxLongEdge = 2200
+            val longEdge = max(cropW, cropH)
+            val rawScale = if (longEdge > 0) (maxLongEdge.toFloat() / longEdge) else 1f
+            val scale = rawScale.coerceIn(1f, 2.5f)
+            val outW = (cropW * scale).toInt()
+            val outH = (cropH * scale).toInt()
+            val scaled = if (scale != 1f) {
+                val s = Bitmap.createScaledBitmap(cropped, outW, outH, true)
+                cropped.recycle()
+                s
+            } else {
+                cropped
+            }
+
+            // Grayscale + contrast boost: the MRZ is black OCR-B on a light
+            // background, so desaturating and stretching contrast makes glyphs
+            // crisp and suppresses the dominant filler confusion (the "<" angle
+            // bracket misread as C/E/K under glare). Done with a ColorMatrix on a
+            // Canvas — no OpenCV dependency.
+            val enhanced = enhanceForOcr(scaled)
+            if (enhanced !== scaled) scaled.recycle()
+
+            // The bitmap is already rotated to portrait, so rotation = 0 here.
+            ScanFrameRoi(
+                image = InputImage.fromBitmap(enhanced, 0),
+                offsetX = left,
+                offsetY = top,
+                scale = scale
+            )
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Desaturate + boost contrast to make dark OCR-B glyphs pop against the light
+     * MRZ background, which suppresses the "<" filler being misread as C/E/K under
+     * glare. Uses a single ColorMatrix (saturation 0, then a contrast scale about
+     * mid-grey). Returns the original bitmap unchanged on failure.
+     */
+    private fun enhanceForOcr(src: Bitmap): Bitmap {
+        return try {
+            val out = Bitmap.createBitmap(src.width, src.height, Bitmap.Config.ARGB_8888)
+            val canvas = android.graphics.Canvas(out)
+            val paint = android.graphics.Paint()
+
+            val gray = android.graphics.ColorMatrix().apply { setSaturation(0f) }
+            // Contrast about mid-grey (128): out = c*in + (1-c)*128.
+            val c = 1.6f
+            val t = (1f - c) * 128f
+            val contrast = android.graphics.ColorMatrix(
+                floatArrayOf(
+                    c, 0f, 0f, 0f, t,
+                    0f, c, 0f, 0f, t,
+                    0f, 0f, c, 0f, t,
+                    0f, 0f, 0f, 1f, 0f
+                )
+            )
+            gray.postConcat(contrast)
+            paint.colorFilter = android.graphics.ColorMatrixColorFilter(gray)
+            canvas.drawBitmap(src, 0f, 0f, paint)
+            out
+        } catch (e: Exception) {
+            src
+        }
+    }
+
     fun cleanup() {
         // Cancel any active recording and delete file
         if (activeRecording != null) {

package/ios/Camera/TrustchexCameraView.swift

@@ -864,28 +864,30 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         // Compute brightness early for OCR-B enhancement decision
         let brightness = computeBrightness(from: pixelBuffer, width: portraitWidth, height: portraitHeight)
 
-        // For text recognition, use original image directly
-        // ML Kit works best with native camera frames
-        let textEnhancedImage = orientedImage
-
-        // Create VisionImage from the image (enhanced or original) for better text recognition
-        // This ensures MLKit processes the image in the correct orientation
-        guard let cgImage = self.ciContext.createCGImage(textEnhancedImage, from: textEnhancedImage.extent) else {
+        // Face detection / base64 use the full portrait frame.
+        guard let cgImage = self.ciContext.createCGImage(orientedImage, from: orientedImage.extent) else {
             resetProcessingState()
             return
         }
         let visionImage = VisionImage(image: UIImage(cgImage: cgImage))
         visionImage.orientation = .up  // Already oriented correctly
-        
-        // Use image for text recognition
-        // ML Kit text recognition best practices (iOS):
-        // - Requires minimum 16x16 pixels per character (ideal 16-24px per character)
-        // - Input image: 1080x1920 (portrait Full HD) provides excellent accuracy at real-time speed
-        // - Each character at ~30px = 36 characters per line @ 1080px width
-        // - Use synchronous results(in:) API from captureOutput(_:didOutput:from:)
-        // - Set AVCaptureVideoDataOutput.alwaysDiscardsLateVideoFrames = true (throttle)
-        // - Get results then render overlay in single step for optimal performance
-        let textVisionImage = visionImage
+
+        // Text recognition: process ONLY the data inside the on-screen scan frame
+        // (matching Android). We crop the portrait frame to the scan-frame ROI
+        // (top 25% / bottom 12% / 4% side margins), UPSCALE it, and grayscale +
+        // contrast-enhance before OCR. This removes front-of-card text and glare
+        // noise and lifts a dense MRZ line above ML Kit's ~16px/char floor.
+        // `mrzRoi` carries the transform back to full portrait-frame coordinates.
+        let mrzRoi = enableTextRecognition
+            ? buildScanFrameRoiImage(orientedImage, portraitWidth: portraitWidth, portraitHeight: portraitHeight)
+            : nil
+        var textVisionImage = visionImage
+        if let roi = mrzRoi,
+           let roiCg = self.ciContext.createCGImage(roi.image, from: roi.image.extent) {
+            let img = VisionImage(image: UIImage(cgImage: roiCg))
+            img.orientation = .up
+            textVisionImage = img
+        }
 
         // Generate JPEG base64 only when JS side explicitly needs the image
         // NOTE: Do NOT auto-generate for face detection - too expensive, causes frame drops
@@ -961,8 +963,16 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
                     let blockY: Int
                     let blockWidth: Int
                     let blockHeight: Int
-                    
-                    if isBufferLandscape {
+
+                    if let roi = mrzRoi {
+                        // OCR ran on the upscaled, already-portrait scan-frame ROI.
+                        // Map the box back to full portrait-frame coordinates:
+                        // divide out the ROI upscale, then add the ROI origin.
+                        blockX = Int(bb.origin.x / roi.scale) + roi.offsetX
+                        blockY = Int(bb.origin.y / roi.scale) + roi.offsetY
+                        blockWidth = Int(bb.width / roi.scale)
+                        blockHeight = Int(bb.height / roi.scale)
+                    } else if isBufferLandscape {
                         // Rotate from landscape (1920x1080) to portrait (1080x1920)
                         // When rotating 90° clockwise (.right):
                         // new_x = old_y
@@ -1041,6 +1051,69 @@ extension TrustchexCameraView: AVCaptureVideoDataOutputSampleBufferDelegate {
         }
     }
 
+    /// A scan-frame ROI prepared for OCR, with the transform back to full-frame coords.
+    private struct ScanFrameRoi {
+        let image: CIImage
+        let offsetX: Int
+        let offsetY: Int
+        let scale: CGFloat
+    }
+
+    /// Crops the portrait frame to the on-screen scan frame (top 25% / bottom 12%
+    /// / 4% side margins — the same rectangle the UI guide draws), UPSCALES it so a
+    /// dense MRZ line clears ML Kit's ~16px/char floor, and grayscale + contrast
+    /// enhances it (the MRZ is dark OCR-B on a light background, so this makes
+    /// glyphs pop and suppresses the "<" filler being misread as a letter under
+    /// glare). Returns nil on failure so the caller falls back to full-frame OCR.
+    /// Mirrors the Android `buildScanFrameRoiImage`.
+    private func buildScanFrameRoiImage(_ portrait: CIImage, portraitWidth: Int, portraitHeight: Int) -> ScanFrameRoi? {
+        let w = portrait.extent.width
+        let h = portrait.extent.height
+        if w < 8 || h < 8 { return nil }
+
+        // Scan-frame rectangle. CIImage origin is BOTTOM-left, so "top 25%" maps to
+        // a y measured from the bottom: cropY = h*0.12 (bottom margin), height =
+        // h*(1 - 0.25 - 0.12).
+        let leftPct: CGFloat = 0.04
+        let rightPct: CGFloat = 0.04
+        let topPct: CGFloat = 0.25
+        let bottomPct: CGFloat = 0.12
+        let cropX = (w * leftPct).rounded()
+        let cropW = (w * (1 - leftPct - rightPct)).rounded()
+        let cropY = (h * bottomPct).rounded()
+        let cropH = (h * (1 - topPct - bottomPct)).rounded()
+        if cropW < 8 || cropH < 8 { return nil }
+
+        let cropRect = CGRect(x: portrait.extent.origin.x + cropX,
+                              y: portrait.extent.origin.y + cropY,
+                              width: cropW, height: cropH)
+        var img = portrait.cropped(to: cropRect)
+        // Move the crop origin to (0,0) so downstream extents are simple.
+        img = img.transformed(by: CGAffineTransform(translationX: -cropRect.origin.x, y: -cropRect.origin.y))
+
+        // Upscale (≤2.5×, long edge capped at 2200) for more pixels per character.
+        let longEdge = max(cropW, cropH)
+        let rawScale = longEdge > 0 ? (2200.0 / longEdge) : 1.0
+        let scale = min(max(rawScale, 1.0), 2.5)
+        if scale != 1.0 {
+            img = img.transformed(by: CGAffineTransform(scaleX: scale, y: scale))
+        }
+
+        // Grayscale (saturation 0) + contrast boost.
+        img = img.applyingFilter("CIColorControls", parameters: [
+            kCIInputSaturationKey: 0.0,
+            kCIInputContrastKey: 1.6
+        ])
+
+        // The crop is taken from the TOP of the portrait frame (UIKit coords), but
+        // CIImage y is bottom-up. The block coords ML Kit returns are top-left in
+        // the OCR image, so the offset back to the portrait frame is the UIKit top
+        // edge (= portraitHeight * topPct) and left edge.
+        let offsetX = Int(cropX)
+        let offsetY = Int((CGFloat(portraitHeight) * topPct).rounded())
+        return ScanFrameRoi(image: img, offsetX: offsetX, offsetY: offsetY, scale: scale)
+    }
+
     private func computeBrightness(from pixelBuffer: CVPixelBuffer, width: Int, height: Int) -> Double {
         guard let yPlane = CVPixelBufferGetBaseAddressOfPlane(pixelBuffer, 0) else { return 128.0 }
         let pixelWidth = CVPixelBufferGetWidthOfPlane(pixelBuffer, 0)