मैं स्विफ्ट के लिए नया हूं और मैं कुछ परियोजनाओं को लागू करने की कोशिश कर रहा हूं। मुझे यह कोड Github से मिला है और यह ठीक काम कर रहा है।

जब आप ऐप पर क्लिक करते हैं, तो यह iPhone स्क्रीन पर एक वीडियो शुरू करता है और यह 'TesseractOCR' का उपयोग करके अक्षरों और वर्णों का पता लगाता है।

समस्या यह है कि वीडियो पूरी स्क्रीन को कवर कर रहा है, मैं कोई बटन नहीं जोड़ पा रहा हूं। अगर मैं एक बटन जोड़ता हूं, तो यह वीडियो के नीचे गायब हो जाता है।

मैंने वीडियो को ऊपर और नीचे से क्रॉप करने के लिए session.sessionPreset = .photo जोड़ने का प्रयास किया लेकिन यह काम नहीं किया। मैंने preview.sessionPreset = .photo जोड़ने का भी प्रयास किया लेकिन काम नहीं किया

नोट: Main.storyboard खाली है।

Attached screenshot

यहाँ कोड है:

import AVFoundation
import UIKit
import Vision
import TesseractOCR


class ViewController: UIViewController, G8TesseractDelegate  {




    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        tesseract?.pageSegmentationMode = .sparseText
        // Recognize only these characters


//        tesseract?.charWhitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890()-+*!/?.,@#$%&"
        tesseract?.charWhitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890"


        if isAuthorized() {
            configureTextDetection()
            configureCamera()
        }
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
    private func configureTextDetection() {
        textDetectionRequest = VNDetectTextRectanglesRequest(completionHandler: handleDetection)
        textDetectionRequest?.reportCharacterBoxes = true
    }
    private func configureCamera() {
        preview.session = session

        let cameraDevices = AVCaptureDevice.DiscoverySession(deviceTypes: [.builtInWideAngleCamera], mediaType: AVMediaType.video, position: .back)
        var cameraDevice: AVCaptureDevice?
        for device in cameraDevices.devices {
            if device.position == .back {
                cameraDevice = device
                break
            }
        }
        do {
            let captureDeviceInput = try AVCaptureDeviceInput(device: cameraDevice!)
            if session.canAddInput(captureDeviceInput) {
                session.addInput(captureDeviceInput)
            }
        }
        catch {
            print("Error occured \(error)")
            return
        }
        session.sessionPreset = .photo   // It was .high
        let videoDataOutput = AVCaptureVideoDataOutput()
        videoDataOutput.setSampleBufferDelegate(self, queue: DispatchQueue(label: "Buffer Queue", qos: .userInteractive, attributes: .concurrent, autoreleaseFrequency: .inherit, target: nil))
        if session.canAddOutput(videoDataOutput) {
            session.addOutput(videoDataOutput)
        }
        preview.videoPreviewLayer.videoGravity = .resize
        session.startRunning()
    }
    private func handleDetection(request: VNRequest, error: Error?) {

        guard let detectionResults = request.results else {
            print("No detection results")
            return
        }
        let textResults = detectionResults.map() {
            return $0 as? VNTextObservation
        }
        if textResults.isEmpty {
            return
        }
        textObservations = textResults as! [VNTextObservation]
        DispatchQueue.main.async {

            guard let sublayers = self.view.layer.sublayers else {
                return
            }
            for layer in sublayers[1...] {
                if (layer as? CATextLayer) == nil {
                    layer.removeFromSuperlayer()
                }
            }
            let viewWidth = self.view.frame.size.width
            let viewHeight = self.view.frame.size.height
            for result in textResults {

                if let textResult = result {

                    let layer = CALayer()
                    var rect = textResult.boundingBox
                    rect.origin.x *= viewWidth
                    rect.size.height *= viewHeight
                    rect.origin.y = ((1 - rect.origin.y) * viewHeight) - rect.size.height
                    rect.size.width *= viewWidth

                    layer.frame = rect
                    layer.borderWidth = 2
                    layer.borderColor = UIColor.red.cgColor
                    self.view.layer.addSublayer(layer)
                }
            }
        }
    }

    private var preview: PreviewView {
        return view as! PreviewView
    }
//    private var cameraView: CameraView {
//        return view as! CameraView
//    }
    private func isAuthorized() -> Bool {
        let authorizationStatus = AVCaptureDevice.authorizationStatus(for: AVMediaType.video)
        switch authorizationStatus {
        case .notDetermined:
            AVCaptureDevice.requestAccess(for: AVMediaType.video,
                                          completionHandler: { (granted:Bool) -> Void in
                                            if granted {
                                                DispatchQueue.main.async {
                                                    self.configureTextDetection()
                                                    self.configureCamera()
                                                }
                                            }
            })
            return true
        case .authorized:
            return true
        case .denied, .restricted: return false
        }
    }
    private var textDetectionRequest: VNDetectTextRectanglesRequest?
    private let session = AVCaptureSession()
    private var textObservations = [VNTextObservation]()
    private var tesseract = G8Tesseract(language: "eng", engineMode: .tesseractOnly)
    private var font = CTFontCreateWithName("Helvetica" as CFString, 18, nil)
}

extension ViewController: AVCaptureVideoDataOutputSampleBufferDelegate {
    // MARK: - Camera Delegate and Setup
    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else {
            return
        }
        var imageRequestOptions = [VNImageOption: Any]()
        if let cameraData = CMGetAttachment(sampleBuffer, key: kCMSampleBufferAttachmentKey_CameraIntrinsicMatrix, attachmentModeOut: nil) {
            imageRequestOptions[.cameraIntrinsics] = cameraData
        }
        let imageRequestHandler = VNImageRequestHandler(cvPixelBuffer: pixelBuffer, orientation: CGImagePropertyOrientation(rawValue: 6)!, options: imageRequestOptions)
        do {
            try imageRequestHandler.perform([textDetectionRequest!])
        }
        catch {
            print("Error occured \(error)")
        }
        var ciImage = CIImage(cvPixelBuffer: pixelBuffer)
        let transform = ciImage.orientationTransform(for: CGImagePropertyOrientation(rawValue: 6)!)
        ciImage = ciImage.transformed(by: transform)
        let size = ciImage.extent.size
        var recognizedTextPositionTuples = [(rect: CGRect, text: String)]()
        for textObservation in textObservations {
            guard let rects = textObservation.characterBoxes else {
                continue
            }
            var xMin = CGFloat.greatestFiniteMagnitude
            var xMax: CGFloat = 0
            var yMin = CGFloat.greatestFiniteMagnitude
            var yMax: CGFloat = 0
            for rect in rects {

                xMin = min(xMin, rect.bottomLeft.x)
                xMax = max(xMax, rect.bottomRight.x)
                yMin = min(yMin, rect.bottomRight.y)
                yMax = max(yMax, rect.topRight.y)
            }
            let imageRect = CGRect(x: xMin * size.width, y: yMin * size.height, width: (xMax - xMin) * size.width, height: (yMax - yMin) * size.height)
            let context = CIContext(options: nil)
            guard let cgImage = context.createCGImage(ciImage, from: imageRect) else {
                continue
            }
            let uiImage = UIImage(cgImage: cgImage)
            tesseract?.image = uiImage
            tesseract?.recognize()
            guard var text = tesseract?.recognizedText else {
                continue
            }
            text = text.trimmingCharacters(in: CharacterSet.newlines)
            if !text.isEmpty {
                let x = xMin
                let y = 1 - yMax
                let width = xMax - xMin
                let height = yMax - yMin
                recognizedTextPositionTuples.append((rect: CGRect(x: x, y: y, width: width, height: height), text: text))



            }
        }
        textObservations.removeAll()
        DispatchQueue.main.async {
            let viewWidth = self.view.frame.size.width
            let viewHeight = self.view.frame.size.height
            guard let sublayers = self.view.layer.sublayers else {
                return
            }
            for layer in sublayers[1...] {

                if let _ = layer as? CATextLayer {
                    layer.removeFromSuperlayer()
                }
            }
            for tuple in recognizedTextPositionTuples {
                let textLayer = CATextLayer()
                textLayer.backgroundColor = UIColor.clear.cgColor
                textLayer.font = self.font
                var rect = tuple.rect

                rect.origin.x *= viewWidth
                rect.size.width *= viewWidth
                rect.origin.y *= viewHeight
                rect.size.height *= viewHeight

                // Increase the size of text layer to show text of large lengths
                rect.size.width += 100
                rect.size.height += 100

                textLayer.frame = rect
                textLayer.string = tuple.text
                textLayer.foregroundColor = UIColor.green.cgColor
                self.view.layer.addSublayer(textLayer)



            }
        }
    }


}
1
ananya 23 फरवरी 2019, 00:57

1 उत्तर

सबसे बढ़िया उत्तर

मूल रूप से CameraView को ViewController के मूल दृश्य के रूप में सेट किया जा रहा है, इसलिए आप इसका आकार नहीं बदल सकते। आपको इसका आकार बदलने के लिए CameraView को ViewController के रूट व्यू के चाइल्ड व्यू में बनाना होगा।

कुछ इसी तरह:

  1. ViewController.swift चुनें
  2. निम्नलिखित को हटा दें

    <कोड>निजी संस्करण कैमरा व्यू: कैमरा व्यू { वापसी दृश्य के रूप में! कैमरा व्यू }

  3. सभी cameraView को self.cameraView से बदलें

  4. निम्नलिखित पंक्ति जोड़ें:

    @IBOutlet var cameraView: CameraView!

  5. सभी self.view को self.cameraView से बदलें

  6. Main.storyboard चुनें
  7. Document Outline में Camera View चुनें
  8. Identity Inspector (⌥⌘3) पर जाएं और Class को साफ करें, जिसमें CameraView होना चाहिए। आपके द्वारा इसे साफ़ करने के बाद, यह UIView दिखाना चाहिए
  9. Library (⇧⌘L) खोलें और मूल Camera View के अंदर एक नया View जोड़ें (इस नए दृश्य के आकार को समायोजित करने के लिए स्वतंत्र महसूस करें)
  10. इस नए दृश्य को चुनें और Identity Inspector (⌥⌘3) पर जाएं और Class को CameraView में बदलें
  11. स्टोरीबोर्ड में View Controller चुनें और Connections Inspector (⌥⌘6) पर जाएं
  12. आउटलेट कनेक्ट करें CameraView

और अगर आपको cameraView की सीमा से बाहर जाने वाला टेक्स्ट पसंद नहीं है, तो आप बस निम्नलिखित को viewDidLoad में जोड़ सकते हैं:

self.cameraView.clipsToBounds = true
1
Bill 23 फरवरी 2019, 05:21