capacitor-plugin-camera-forked 3.1.121 → 3.1.123

package/android/src/main/java/com/tonyxlh/capacitor/camera/BlurDetectionHelper.java

@@ -56,7 +56,7 @@ import java.util.concurrent.atomic.AtomicReference;
 public class BlurDetectionHelper {
     private static final String TAG = "BlurDetectionHelper";
     private static final String MODEL_FILENAME = "blur_detection_model.tflite";
-    private static int INPUT_SIZE = 224; // Will be updated based on actual model input size
+    private static int INPUT_SIZE = 600; // Will be updated based on actual model input size
     private static final int NUM_CLASSES = 2; // blur, sharp
     
     // Timeout settings
@@ -66,6 +66,11 @@ public class BlurDetectionHelper {
     private static final double MIN_WORD_CONFIDENCE = 0.8; // 80% confidence threshold
     private static final double AT_LEAST_N_PERCENT_OF_WORDS_ARE_READABLE = 0.6; // 60% of words are readable
     private static final double AT_LEAST_N_PERCENT_OF_AVERAGE_CONFIDENCE = 0.85; // 85% of average confidence
+
+    // Method based confidence threshold
+    private static final double MIN_SHARP_CONFIDENCE_FOR_OBJECT_DETECTION = 0.75; // 75% confidence threshold
+    private static final double MIN_SHARP_CONFIDENCE_FOR_TEXT_DETECTION = 0.15; // 15% confidence threshold
+    private static final double MIN_SHARP_CONFIDENCE_FOR_FULL_IMAGE = 0.75; // 70% confidence threshold
     
     // TFLite components
     private Interpreter tflite;
@@ -91,10 +96,9 @@ public class BlurDetectionHelper {
 
 
     public BlurDetectionHelper() {
-        // Initialize image processor for MobileNetV2 preprocessing
+        // Initialize image processor for MobileNetV2 preprocessing with aspect ratio preservation
         imageProcessor = new ImageProcessor.Builder()
-                .add(new ResizeWithCropOrPadOp(INPUT_SIZE, INPUT_SIZE))
-                .add(new ResizeOp(INPUT_SIZE, INPUT_SIZE, ResizeOp.ResizeMethod.BILINEAR))
+                .add(new ResizeWithCropOrPadOp(INPUT_SIZE, INPUT_SIZE)) // This preserves aspect ratio by cropping/padding
                 .build();
         
         // Initialize common words dictionary
@@ -146,10 +150,9 @@ public class BlurDetectionHelper {
                 if (modelInputSize != INPUT_SIZE) {
                     INPUT_SIZE = modelInputSize;
                     
-                    // Recreate image processor with correct size
+                    // Recreate image processor with correct size and aspect ratio preservation
                     imageProcessor = new ImageProcessor.Builder()
-                        .add(new ResizeWithCropOrPadOp(INPUT_SIZE, INPUT_SIZE))
-                        .add(new ResizeOp(INPUT_SIZE, INPUT_SIZE, ResizeOp.ResizeMethod.BILINEAR))
+                        .add(new ResizeWithCropOrPadOp(INPUT_SIZE, INPUT_SIZE)) // Preserves aspect ratio
                         .build();
                 }
             }
@@ -239,7 +242,7 @@ public class BlurDetectionHelper {
                             Bitmap roi = cropBitmap(bitmap, boundingBox);
                             if (roi != null) {
                                 // Run TFLite blur detection on ROI
-                                Map<String, Object> roiResult = detectBlurWithTFLiteConfidence(roi);
+                                Map<String, Object> roiResult = detectBlurWithTFLiteConfidence(roi, MIN_SHARP_CONFIDENCE_FOR_OBJECT_DETECTION);
 
                                 Log.d(TAG, "Object Detection ROI Result isBlur: " + roiResult.get("isBlur"));
                                 roiResult.put("boundingBox", boundingBox);
@@ -299,7 +302,7 @@ public class BlurDetectionHelper {
             
             // Step 3: Full-Image Blur Detection (Final Fallback)
             Log.d(TAG, "Step 3: Using Full-Image Blur Detection");
-            return detectBlurWithTFLiteConfidence(bitmap);
+            return detectBlurWithTFLiteConfidence(bitmap, MIN_SHARP_CONFIDENCE_FOR_FULL_IMAGE);
             
         } catch (Exception e) {
             Log.e(TAG, "Error in blur detection pipeline: " + e.getMessage());
@@ -329,6 +332,9 @@ public class BlurDetectionHelper {
             // Preprocess image for model (resize and potential enhancement)
             inputImageBuffer.load(processedBitmap);
             inputImageBuffer = imageProcessor.process(inputImageBuffer);
+            
+            // Ensure black padding for better accuracy (matches iOS implementation)
+            ensureBlackPadding(inputImageBuffer);
 
             // Get tensor buffer
             ByteBuffer tensorBuffer = inputImageBuffer.getBuffer();
@@ -355,7 +361,7 @@ public class BlurDetectionHelper {
             double sharpConfidence = probabilities.length > 1 ? probabilities[1] : 0.0;
 
             // Determine if image is blurry using TFLite confidence
-            boolean isBlur = sharpConfidence < 0.80;
+            boolean isBlur = sharpConfidence < MIN_SHARP_CONFIDENCE_FOR_FULL_IMAGE;
             
             
             // Return 1.0 for blur, 0.0 for sharp (to maintain double return type)
@@ -420,6 +426,37 @@ public class BlurDetectionHelper {
          return normalizedBuffer;
      }
 
+    /**
+     * Ensure black padding in the processed image buffer for better accuracy
+     * @param tensorImage Processed tensor image
+     */
+    private void ensureBlackPadding(TensorImage tensorImage) {
+        ByteBuffer buffer = tensorImage.getBuffer();
+        DataType dataType = tensorImage.getDataType();
+        
+        if (dataType == DataType.FLOAT32) {
+            // For float32, ensure padding areas are 0.0 (black)
+            FloatBuffer floatBuffer = buffer.asFloatBuffer();
+            int totalPixels = INPUT_SIZE * INPUT_SIZE * 3;
+            
+            // Check if we need to fill with zeros (black)
+            for (int i = 0; i < totalPixels; i++) {
+                if (floatBuffer.get(i) < 0.001f) { // Near zero values
+                    floatBuffer.put(i, 0.0f); // Ensure exact zero (black)
+                }
+            }
+        } else if (dataType == DataType.UINT8) {
+            // For uint8, ensure padding areas are 0 (black)
+            buffer.rewind();
+            while (buffer.hasRemaining()) {
+                byte value = buffer.get();
+                if (value == 0) {
+                    buffer.put(buffer.position() - 1, (byte) 0); // Ensure exact zero
+                }
+            }
+        }
+    }
+
     /**
      * Normalize image buffer from uint8 [0,255] to float32 [0,1]
      * @param uint8Buffer Input buffer with uint8 pixel values
@@ -498,7 +535,7 @@ public class BlurDetectionHelper {
      * @param bitmap Input image bitmap
      * @return Map with isBlur, blurConfidence, and sharpConfidence
      */
-    public java.util.Map<String, Object> detectBlurWithTFLiteConfidence(Bitmap bitmap) {
+    public java.util.Map<String, Object> detectBlurWithTFLiteConfidence(Bitmap bitmap, double minSharpConfidence) {
         java.util.Map<String, Object> result = new java.util.HashMap<>();
         
         if (!isInitialized || tflite == null) {
@@ -525,6 +562,9 @@ public class BlurDetectionHelper {
             // Preprocess image for model (resize and potential enhancement)
             inputImageBuffer.load(processedBitmap);
             inputImageBuffer = imageProcessor.process(inputImageBuffer);
+            
+            // Ensure black padding for better accuracy (matches iOS implementation)
+            ensureBlackPadding(inputImageBuffer);
 
             // Get tensor buffer
             ByteBuffer tensorBuffer = inputImageBuffer.getBuffer();
@@ -553,7 +593,7 @@ public class BlurDetectionHelper {
             Log.d(TAG, "TFLite Blur confidence: " + blurConfidence + " Sharp confidence: " + sharpConfidence);
 
             // Determine if image is blurry using TFLite confidence
-            boolean isBlur = sharpConfidence < 0.80;
+            boolean isBlur = sharpConfidence < minSharpConfidence;
             
             Log.d(TAG, "TFLite Blur detection isBlur: " + isBlur);
             
@@ -783,7 +823,7 @@ public class BlurDetectionHelper {
                 try {
                     Bitmap cropped = cropBitmap(bitmap, roi);
                     if (cropped != null) {
-                        Map<String, Object> result = detectBlurWithTFLiteConfidence(cropped);
+                        Map<String, Object> result = detectBlurWithTFLiteConfidence(cropped, MIN_SHARP_CONFIDENCE_FOR_TEXT_DETECTION);
                         result.put("boundingBox", roi);
                         results.add(result);
                     }

package/ios/Plugin/BlurDetectionHelper.swift

@@ -12,8 +12,8 @@ import MLKitVision
 class BlurDetectionHelper {
     
     private static let TAG = "BlurDetectionHelper"
-    private static let INPUT_WIDTH = 224 // Model's expected input width
-    private static let INPUT_HEIGHT = 224 // Model's expected input height
+    private static let INPUT_WIDTH = 600 // Model's expected input width
+    private static let INPUT_HEIGHT = 600 // Model's expected input height
     private static let BATCH_SIZE = 1 // Model expects a batch size of 1
     private static let NUM_CHANNELS = 3 // RGB
     private static let NUM_CLASSES = 2 // blur, sharp
@@ -27,10 +27,10 @@ class BlurDetectionHelper {
     private static let AT_LEAST_N_PERCENT_OF_AVERAGE_CONFIDENCE: Double = 0.85 // 85% of average confidence
 
     // Method based confidence threshold
-    private static let MIN_SHARP_CONFIDENCE_FOR_OBJECT_DETECTION: Double = 0.4 // 40% confidence threshold
-    private static let MIN_SHARP_CONFIDENCE_FOR_TEXT_DETECTION: Double = 0.1 // 10% confidence threshold
-    private static let MIN_SHARP_CONFIDENCE_FOR_FULL_IMAGE: Double = 0.7 // 70% confidence threshold
-    
+    private static let MIN_SHARP_CONFIDENCE_FOR_OBJECT_DETECTION: Double = 0.75 // 75% confidence threshold
+    private static let MIN_SHARP_CONFIDENCE_FOR_TEXT_DETECTION: Double = 0.15 // 15% confidence threshold
+    private static let MIN_SHARP_CONFIDENCE_FOR_FULL_IMAGE: Double = 0.75 // 75% confidence threshold
+    	
     private var interpreter: Interpreter?
     private var isInitialized = false
     
@@ -391,11 +391,37 @@ class BlurDetectionHelper {
     }
     
     /**
-     * Resize image to target size
+     * Resize image to target size while maintaining aspect ratio
      */
     private func resizeImage(_ image: UIImage, to size: CGSize) -> UIImage? {
-        UIGraphicsBeginImageContextWithOptions(size, false, 1.0)
-        image.draw(in: CGRect(origin: .zero, size: size))
+        let targetSize = size
+        let imageSize = image.size
+        
+        // Calculate aspect ratio preserving dimensions
+        let widthRatio = targetSize.width / imageSize.width
+        let heightRatio = targetSize.height / imageSize.height
+        let scaleFactor = min(widthRatio, heightRatio)
+        
+        let scaledSize = CGSize(
+            width: imageSize.width * scaleFactor,
+            height: imageSize.height * scaleFactor
+        )
+        
+        // Create a square canvas with the target size
+        UIGraphicsBeginImageContextWithOptions(targetSize, false, 1.0)
+        
+        // Calculate position to center the scaled image
+        let x = (targetSize.width - scaledSize.width) / 2
+        let y = (targetSize.height - scaledSize.height) / 2
+        let drawRect = CGRect(x: x, y: y, width: scaledSize.width, height: scaledSize.height)
+        
+        // Fill background with black (or white) to pad the image
+        UIColor.black.setFill()
+        UIRectFill(CGRect(origin: .zero, size: targetSize))
+        
+        // Draw the scaled image centered
+        image.draw(in: drawRect)
+        
         let resizedImage = UIGraphicsGetImageFromCurrentImageContext()
         UIGraphicsEndImageContext()
         return resizedImage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-plugin-camera-forked",
-  "version": "3.1.121",
+  "version": "3.1.123",
   "description": "A capacitor camera plugin - A custom Capacitor camera plugin with additional features.",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",