react-native-rectangle-doc-scanner 3.10.0 → 3.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "3.10.0",
+  "version": "3.12.0",
   "description": "Native-backed document scanner for React Native with customizable overlays.",
   "license": "MIT",
   "main": "dist/index.js",

package/vendor/react-native-document-scanner/ios/DocumentScannerView.m

@@ -16,14 +16,21 @@
     return self;
 }
 
-- (void)didMoveToWindow {
-    [super didMoveToWindow];
-    if (self.window && !_hasSetupCamera) {
-        // Only setup camera once when view is added to window
+- (void)layoutSubviews {
+    [super layoutSubviews];
+
+    // Setup camera after layout is complete and bounds are valid
+    if (!_hasSetupCamera && self.window && !CGRectIsEmpty(self.bounds)) {
+        NSLog(@"[DocumentScanner] Setting up camera with bounds: %@", NSStringFromCGRect(self.bounds));
         [self setupCameraView];
         [self start];
         _hasSetupCamera = YES;
-    } else if (!self.window && _hasSetupCamera) {
+    }
+}
+
+- (void)didMoveToWindow {
+    [super didMoveToWindow];
+    if (!self.window && _hasSetupCamera) {
         // Stop camera when view is removed from window
         [self stop];
     }

package/vendor/react-native-document-scanner/ios/IPDFCameraViewController.m

@@ -15,19 +15,17 @@
 #import <ImageIO/ImageIO.h>
 #import <GLKit/GLKit.h>
 
-@interface IPDFCameraViewController () <AVCaptureVideoDataOutputSampleBufferDelegate, AVCapturePhotoCaptureDelegate>
+@interface IPDFCameraViewController () <AVCaptureVideoDataOutputSampleBufferDelegate>
 
 @property (nonatomic,strong) AVCaptureSession *captureSession;
 @property (nonatomic,strong) AVCaptureDevice *captureDevice;
 @property (nonatomic,strong) EAGLContext *context;
 
-@property (nonatomic, strong) AVCapturePhotoOutput* photoOutput;
+@property (nonatomic, strong) AVCaptureStillImageOutput* stillImageOutput;
 
 @property (nonatomic, assign) BOOL forceStop;
 @property (nonatomic, assign) float lastDetectionRate;
 
-@property (nonatomic, copy) void (^photoCaptureCompletionHandler)(UIImage *croppedImage, UIImage *initialImage, CIRectangleFeature *rectangleFeature);
-
 @end
 
 @implementation IPDFCameraViewController
@@ -127,95 +125,33 @@
 
     NSError *error = nil;
     AVCaptureDeviceInput* input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
-
-    // Set session preset to highest quality
-    if ([session canSetSessionPreset:AVCaptureSessionPresetHigh]) {
-        session.sessionPreset = AVCaptureSessionPresetHigh;
-    } else {
-        session.sessionPreset = AVCaptureSessionPresetPhoto;
-    }
-
+    session.sessionPreset = AVCaptureSessionPresetPhoto;
     [session addInput:input];
 
     AVCaptureVideoDataOutput *dataOutput = [[AVCaptureVideoDataOutput alloc] init];
     [dataOutput setAlwaysDiscardsLateVideoFrames:YES];
     [dataOutput setVideoSettings:@{(id)kCVPixelBufferPixelFormatTypeKey:@(kCVPixelFormatType_32BGRA)}];
-    // Use background queue for video processing to avoid blocking UI
-    dispatch_queue_t videoQueue = dispatch_queue_create("com.scanner.videoQueue", DISPATCH_QUEUE_SERIAL);
-    [dataOutput setSampleBufferDelegate:self queue:videoQueue];
+    [dataOutput setSampleBufferDelegate:self queue:dispatch_get_main_queue()];
     [session addOutput:dataOutput];
 
-    // Use modern AVCapturePhotoOutput for best quality
-    self.photoOutput = [[AVCapturePhotoOutput alloc] init];
-
-    if ([session canAddOutput:self.photoOutput]) {
-        [session addOutput:self.photoOutput];
-
-        // Enable high quality photo capture
-        if (@available(iOS 13.0, *)) {
-            self.photoOutput.maxPhotoQualityPrioritization = AVCapturePhotoQualityPrioritizationQuality;
-            // maxPhotoDimensions defaults to the highest supported resolution automatically
-        }
-    }
+    self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
+    [session addOutput:self.stillImageOutput];
 
     AVCaptureConnection *connection = [dataOutput.connections firstObject];
     [connection setVideoOrientation:AVCaptureVideoOrientationPortrait];
 
-    // Enable video stabilization for better quality
-    if ([connection isVideoStabilizationSupported]) {
-        [connection setPreferredVideoStabilizationMode:AVCaptureVideoStabilizationModeAuto];
-    }
-
-    // Configure device for best quality
-    if ([device lockForConfiguration:nil])
+    if (device.isFlashAvailable)
     {
-        // Disable flash for better natural lighting
-        if (device.isFlashAvailable) {
-            [device setFlashMode:AVCaptureFlashModeOff];
-        }
+        [device lockForConfiguration:nil];
+        [device setFlashMode:AVCaptureFlashModeOff];
+        [device unlockForConfiguration];
 
-        // Enable continuous autofocus for sharp images
-        if ([device isFocusModeSupported:AVCaptureFocusModeContinuousAutoFocus]) {
+        if ([device isFocusModeSupported:AVCaptureFocusModeContinuousAutoFocus])
+        {
+            [device lockForConfiguration:nil];
             [device setFocusMode:AVCaptureFocusModeContinuousAutoFocus];
+            [device unlockForConfiguration];
         }
-
-        // Enable continuous auto exposure
-        if ([device isExposureModeSupported:AVCaptureExposureModeContinuousAutoExposure]) {
-            [device setExposureMode:AVCaptureExposureModeContinuousAutoExposure];
-        }
-
-        // Enable auto white balance
-        if ([device isWhiteBalanceModeSupported:AVCaptureWhiteBalanceModeContinuousAutoWhiteBalance]) {
-            [device setWhiteBalanceMode:AVCaptureWhiteBalanceModeContinuousAutoWhiteBalance];
-        }
-
-        // Enable low light boost if available
-        if (device.isLowLightBoostSupported) {
-            [device setAutomaticallyEnablesLowLightBoostWhenAvailable:YES];
-        }
-
-        // Set active video format to highest resolution
-        if (@available(iOS 13.0, *)) {
-            AVCaptureDeviceFormat *bestFormat = nil;
-            AVFrameRateRange *bestFrameRateRange = nil;
-            for (AVCaptureDeviceFormat *format in [device formats]) {
-                CMVideoDimensions dimensions = CMVideoFormatDescriptionGetDimensions(format.formatDescription);
-                // Prefer 4K resolution (3840x2160)
-                if (dimensions.width == 3840 && dimensions.height == 2160) {
-                    for (AVFrameRateRange *range in format.videoSupportedFrameRateRanges) {
-                        if (bestFormat == nil || range.maxFrameRate > bestFrameRateRange.maxFrameRate) {
-                            bestFormat = format;
-                            bestFrameRateRange = range;
-                        }
-                    }
-                }
-            }
-            if (bestFormat) {
-                [device setActiveFormat:bestFormat];
-            }
-        }
-
-        [device unlockForConfiguration];
     }
 
     [session commitConfiguration];
@@ -300,15 +236,10 @@
             fromRect = CGRectMake(0, yOffset, imageExtent.size.width, newHeight);
         }
 
-        // Render on main thread for OpenGL operations
-        dispatch_async(dispatch_get_main_queue(), ^{
-            if (self.context && _coreImageContext && _glkView) {
-                [EAGLContext setCurrentContext:self.context];
-                [_coreImageContext drawImage:image inRect:drawRect fromRect:fromRect];
-                [self.context presentRenderbuffer:GL_RENDERBUFFER];
-                [_glkView setNeedsDisplay];
-            }
-        });
+        [_coreImageContext drawImage:image inRect:drawRect fromRect:fromRect];
+        [self.context presentRenderbuffer:GL_RENDERBUFFER];
+
+        [_glkView setNeedsDisplay];
     }
 }
 
@@ -450,15 +381,6 @@
 {
     if (_isCapturing) return;
 
-    // Check if photoOutput is available
-    if (!self.photoOutput) {
-        NSLog(@"Error: photoOutput is nil");
-        if (completionHandler) {
-            completionHandler(nil, nil, nil);
-        }
-        return;
-    }
-
     __weak typeof(self) weakSelf = self;
 
     [weakSelf hideGLKView:YES completion:^
@@ -471,27 +393,70 @@
 
     _isCapturing = YES;
 
-    // Store completion handler for delegate callback
-    self.photoCaptureCompletionHandler = completionHandler;
-
-    // Create photo settings with maximum quality - use JPEG for compatibility
-    AVCapturePhotoSettings *photoSettings = [AVCapturePhotoSettings photoSettings];
-
-    // Enable high resolution photo capture
-    photoSettings.highResolutionPhotoEnabled = YES;
-
-    // Set maximum quality prioritization (iOS 13+)
-    if (@available(iOS 13.0, *)) {
-        photoSettings.photoQualityPrioritization = AVCapturePhotoQualityPrioritizationQuality;
-    }
-
-    // Enable auto flash
-    if (self.photoOutput.supportedFlashModes && [self.photoOutput.supportedFlashModes containsObject:@(AVCaptureFlashModeAuto)]) {
-        photoSettings.flashMode = AVCaptureFlashModeAuto;
+    AVCaptureConnection *videoConnection = nil;
+    for (AVCaptureConnection *connection in self.stillImageOutput.connections)
+    {
+        for (AVCaptureInputPort *port in [connection inputPorts])
+        {
+            if ([[port mediaType] isEqual:AVMediaTypeVideo] )
+            {
+                videoConnection = connection;
+                break;
+            }
+        }
+        if (videoConnection) break;
     }
 
-    // Capture photo - delegate will be called
-    [self.photoOutput capturePhotoWithSettings:photoSettings delegate:self];
+    [self.stillImageOutput captureStillImageAsynchronouslyFromConnection:videoConnection completionHandler: ^(CMSampleBufferRef imageSampleBuffer, NSError *error)
+     {
+         NSData *imageData = [AVCaptureStillImageOutput jpegStillImageNSDataRepresentation:imageSampleBuffer];
+
+         if (weakSelf.cameraViewType == IPDFCameraViewTypeBlackAndWhite || weakSelf.isBorderDetectionEnabled)
+         {
+             CIImage *enhancedImage = [CIImage imageWithData:imageData];
+
+             if (weakSelf.cameraViewType == IPDFCameraViewTypeBlackAndWhite)
+             {
+                 enhancedImage = [self filteredImageUsingEnhanceFilterOnImage:enhancedImage];
+             }
+             else
+             {
+                 enhancedImage = [self filteredImageUsingContrastFilterOnImage:enhancedImage];
+             }
+
+             if (weakSelf.isBorderDetectionEnabled && rectangleDetectionConfidenceHighEnough(_imageDedectionConfidence))
+             {
+                 CIRectangleFeature *rectangleFeature = [self biggestRectangleInRectangles:[[self highAccuracyRectangleDetector] featuresInImage:enhancedImage]];
+
+                 if (rectangleFeature)
+                 {
+                     enhancedImage = [self correctPerspectiveForImage:enhancedImage withFeatures:rectangleFeature];
+
+                     UIGraphicsBeginImageContext(CGSizeMake(enhancedImage.extent.size.height, enhancedImage.extent.size.width));
+                     [[UIImage imageWithCIImage:enhancedImage scale:1.0 orientation:UIImageOrientationRight] drawInRect:CGRectMake(0,0, enhancedImage.extent.size.height, enhancedImage.extent.size.width)];
+                     UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
+                     UIImage *initialImage = [UIImage imageWithData:imageData];
+                     UIGraphicsEndImageContext();
+
+                     [weakSelf hideGLKView:NO completion:nil];
+                     completionHandler(image, initialImage, rectangleFeature);
+                 }
+             } else {
+                 [weakSelf hideGLKView:NO completion:nil];
+                 UIImage *initialImage = [UIImage imageWithData:imageData];
+                 completionHandler(initialImage, initialImage, nil);
+             }
+
+         }
+         else
+         {
+             [weakSelf hideGLKView:NO completion:nil];
+             UIImage *initialImage = [UIImage imageWithData:imageData];
+             completionHandler(initialImage, initialImage, nil);
+         }
+
+         _isCapturing = NO;
+     }];
 }
 
 - (void)hideGLKView:(BOOL)hidden completion:(void(^)())completion
@@ -609,103 +574,4 @@ BOOL rectangleDetectionConfidenceHighEnough(float confidence)
     return (confidence > 1.0);
 }
 
-#pragma mark - AVCapturePhotoCaptureDelegate
-
-- (void)captureOutput:(AVCapturePhotoOutput *)output didFinishProcessingPhoto:(AVCapturePhoto *)photo error:(NSError *)error {
-    __weak typeof(self) weakSelf = self;
-
-    if (error) {
-        NSLog(@"Error capturing photo: %@", error);
-        _isCapturing = NO;
-        [weakSelf hideGLKView:NO completion:nil];
-        if (self.photoCaptureCompletionHandler) {
-            self.photoCaptureCompletionHandler(nil, nil, nil);
-            self.photoCaptureCompletionHandler = nil;
-        }
-        return;
-    }
-
-    // Get high quality image data
-    NSData *imageData = [photo fileDataRepresentation];
-
-    if (!imageData) {
-        NSLog(@"Failed to get image data from photo");
-        _isCapturing = NO;
-        [weakSelf hideGLKView:NO completion:nil];
-        if (self.photoCaptureCompletionHandler) {
-            self.photoCaptureCompletionHandler(nil, nil, nil);
-            self.photoCaptureCompletionHandler = nil;
-        }
-        return;
-    }
-
-    // Process image
-    if (weakSelf.cameraViewType == IPDFCameraViewTypeBlackAndWhite || weakSelf.isBorderDetectionEnabled)
-    {
-        CIImage *enhancedImage = [CIImage imageWithData:imageData];
-
-        if (weakSelf.cameraViewType == IPDFCameraViewTypeBlackAndWhite)
-        {
-            enhancedImage = [self filteredImageUsingEnhanceFilterOnImage:enhancedImage];
-        }
-        else
-        {
-            enhancedImage = [self filteredImageUsingContrastFilterOnImage:enhancedImage];
-        }
-
-        if (weakSelf.isBorderDetectionEnabled && rectangleDetectionConfidenceHighEnough(_imageDedectionConfidence))
-        {
-            CIRectangleFeature *rectangleFeature = [self biggestRectangleInRectangles:[[self highAccuracyRectangleDetector] featuresInImage:enhancedImage]];
-
-            if (rectangleFeature)
-            {
-                enhancedImage = [self correctPerspectiveForImage:enhancedImage withFeatures:rectangleFeature];
-
-                // Convert CIImage to UIImage with high quality using CIContext
-                CIContext *ciContext = [CIContext contextWithOptions:@{kCIContextUseSoftwareRenderer: @(NO)}];
-
-                // Apply rotation to match device orientation
-                CGAffineTransform transform = CGAffineTransformMakeRotation(-M_PI_2);
-                enhancedImage = [enhancedImage imageByApplyingTransform:transform];
-
-                // Convert to CGImage first for better quality
-                CGImageRef cgImage = [ciContext createCGImage:enhancedImage fromRect:enhancedImage.extent];
-                UIImage *image = [UIImage imageWithCGImage:cgImage scale:1.0 orientation:UIImageOrientationUp];
-                CGImageRelease(cgImage);
-
-                UIImage *initialImage = [UIImage imageWithData:imageData];
-
-                [weakSelf hideGLKView:NO completion:nil];
-                _isCapturing = NO;
-
-                if (self.photoCaptureCompletionHandler) {
-                    self.photoCaptureCompletionHandler(image, initialImage, rectangleFeature);
-                    self.photoCaptureCompletionHandler = nil;
-                }
-            }
-        } else {
-            [weakSelf hideGLKView:NO completion:nil];
-            _isCapturing = NO;
-            UIImage *initialImage = [UIImage imageWithData:imageData];
-
-            if (self.photoCaptureCompletionHandler) {
-                self.photoCaptureCompletionHandler(initialImage, initialImage, nil);
-                self.photoCaptureCompletionHandler = nil;
-            }
-        }
-
-    }
-    else
-    {
-        [weakSelf hideGLKView:NO completion:nil];
-        _isCapturing = NO;
-        UIImage *initialImage = [UIImage imageWithData:imageData];
-
-        if (self.photoCaptureCompletionHandler) {
-            self.photoCaptureCompletionHandler(initialImage, initialImage, nil);
-            self.photoCaptureCompletionHandler = nil;
-        }
-    }
-}
-
 @end

package/vendor/react-native-document-scanner/ios/IPDFCameraViewController_simple.m

@@ -0,0 +1,163 @@
+// This file contains only the key methods we need to modify
+// setupCameraView - use original simple version
+// layoutSubviews - add for frame updates
+// captureOutput - add aspect fill logic
+
+- (void)layoutSubviews
+{
+    [super layoutSubviews];
+
+    // Update GLKView frame to match parent bounds
+    if (_glkView) {
+        _glkView.frame = self.bounds;
+    }
+}
+
+- (void)createGLKView
+{
+    if (self.context) return;
+
+    self.context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2];
+    GLKView *view = [[GLKView alloc] initWithFrame:self.bounds];
+    view.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+    view.translatesAutoresizingMaskIntoConstraints = YES;
+    view.context = self.context;
+    view.contentScaleFactor = [UIScreen mainScreen].scale;  // 화질 개선
+    view.drawableDepthFormat = GLKViewDrawableDepthFormat24;
+    [self insertSubview:view atIndex:0];
+    _glkView = view;
+    glGenRenderbuffers(1, &_renderBuffer);
+    glBindRenderbuffer(GL_RENDERBUFFER, _renderBuffer);
+    _coreImageContext = [CIContext contextWithEAGLContext:self.context];
+    [EAGLContext setCurrentContext:self.context];
+}
+
+- (void)setupCameraView
+{
+    [self createGLKView];
+
+    AVCaptureDevice *device = nil;
+    NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeVideo];
+    for (AVCaptureDevice *possibleDevice in devices) {
+        if (self.useFrontCam) {
+            if ([possibleDevice position] == AVCaptureDevicePositionFront) {
+                device = possibleDevice;
+            }
+        } else {
+            if ([possibleDevice position] != AVCaptureDevicePositionFront) {
+                device = possibleDevice;
+            }
+        }
+    }
+    if (!device) return;
+
+    _imageDedectionConfidence = 0.0;
+
+    AVCaptureSession *session = [[AVCaptureSession alloc] init];
+    self.captureSession = session;
+    [session beginConfiguration];
+    self.captureDevice = device;
+
+    NSError *error = nil;
+    AVCaptureDeviceInput* input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
+    session.sessionPreset = AVCaptureSessionPresetPhoto;
+    [session addInput:input];
+
+    AVCaptureVideoDataOutput *dataOutput = [[AVCaptureVideoDataOutput alloc] init];
+    [dataOutput setAlwaysDiscardsLateVideoFrames:YES];
+    [dataOutput setVideoSettings:@{(id)kCVPixelBufferPixelFormatTypeKey:@(kCVPixelFormatType_32BGRA)}];
+    [dataOutput setSampleBufferDelegate:self queue:dispatch_get_main_queue()];
+    [session addOutput:dataOutput];
+
+    self.stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
+    [session addOutput:self.stillImageOutput];
+
+    AVCaptureConnection *connection = [dataOutput.connections firstObject];
+    [connection setVideoOrientation:AVCaptureVideoOrientationPortrait];
+
+    if (device.isFlashAvailable)
+    {
+        [device lockForConfiguration:nil];
+        [device setFlashMode:AVCaptureFlashModeOff];
+        [device unlockForConfiguration];
+
+        if ([device isFocusModeSupported:AVCaptureFocusModeContinuousAutoFocus])
+        {
+            [device lockForConfiguration:nil];
+            [device setFocusMode:AVCaptureFocusModeContinuousAutoFocus];
+            [device unlockForConfiguration];
+        }
+    }
+
+    [session commitConfiguration];
+}
+
+-(void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection
+{
+    if (self.forceStop) return;
+    if (_isStopped || _isCapturing || !CMSampleBufferIsValid(sampleBuffer)) return;
+
+    CVPixelBufferRef pixelBuffer = (CVPixelBufferRef)CMSampleBufferGetImageBuffer(sampleBuffer);
+
+    CIImage *image = [CIImage imageWithCVPixelBuffer:pixelBuffer];
+
+    if (self.cameraViewType != IPDFCameraViewTypeNormal)
+    {
+        image = [self filteredImageUsingEnhanceFilterOnImage:image];
+    }
+    else
+    {
+        image = [self filteredImageUsingContrastFilterOnImage:image];
+    }
+
+    if (self.isBorderDetectionEnabled)
+    {
+        if (_borderDetectFrame)
+        {
+            _borderDetectLastRectangleFeature = [self biggestRectangleInRectangles:[[self highAccuracyRectangleDetector] featuresInImage:image]];
+            _borderDetectFrame = NO;
+        }
+
+        if (_borderDetectLastRectangleFeature)
+        {
+            _imageDedectionConfidence += .5;
+
+            image = [self drawHighlightOverlayForPoints:image topLeft:_borderDetectLastRectangleFeature.topLeft topRight:_borderDetectLastRectangleFeature.topRight bottomLeft:_borderDetectLastRectangleFeature.bottomLeft bottomRight:_borderDetectLastRectangleFeature.bottomRight];
+        }
+        else
+        {
+            _imageDedectionConfidence = 0.0f;
+        }
+    }
+
+    if (self.context && _coreImageContext)
+    {
+        // Calculate the rect to draw the image with aspect fill
+        CGRect drawRect = self.bounds;
+        CGRect imageExtent = image.extent;
+
+        // Calculate aspect ratios
+        CGFloat imageAspect = imageExtent.size.width / imageExtent.size.height;
+        CGFloat viewAspect = drawRect.size.width / drawRect.size.height;
+
+        CGRect fromRect = imageExtent;
+
+        // Aspect fill: crop the image to fill the view
+        if (imageAspect > viewAspect) {
+            // Image is wider, crop width
+            CGFloat newWidth = imageExtent.size.height * viewAspect;
+            CGFloat xOffset = (imageExtent.size.width - newWidth) / 2.0;
+            fromRect = CGRectMake(xOffset, 0, newWidth, imageExtent.size.height);
+        } else {
+            // Image is taller, crop height
+            CGFloat newHeight = imageExtent.size.width / viewAspect;
+            CGFloat yOffset = (imageExtent.size.height - newHeight) / 2.0;
+            fromRect = CGRectMake(0, yOffset, imageExtent.size.width, newHeight);
+        }
+
+        [_coreImageContext drawImage:image inRect:drawRect fromRect:fromRect];
+        [self.context presentRenderbuffer:GL_RENDERBUFFER];
+
+        [_glkView setNeedsDisplay];
+    }
+}