func session(_ session: ARSession, didUpdate frame: ARFrame) {
    // Do not enqueue other buffers for processing while another Vision task is still running.
    // The camera stream has only a finite amount of buffers available; holding too many buffers for analysis would starve the camera.
    guard currentBuffer == nil, case .normal = frame.camera.trackingState else {
        return
    }

    // Retain the image buffer for Vision processing.
    self.currentBuffer = frame.capturedImage
    processCurrentImage()
}

// Most computer vision tasks are not rotation agnostic so it is important to pass in the orientation of the image with respect to device.
let orientation = CGImagePropertyOrientation(UIDevice.current.orientation)

let requestHandler = VNImageRequestHandler(cvPixelBuffer: currentBuffer!, orientation: orientation)

visionQueue.async {
    do {
    // Release the pixel buffer when done, allowing the next buffer to be processed.
        defer { self.currentBuffer = nil }
        try requestHandler.perform([self.rectangleRequest, self.textRequest])
        self.recognizeTexts(cvPixelBuffer: self.currentBuffer!)
    } catch {
        print("Error: Vision request failed with error \"\(error)\"")
    }
}

func textDetectionHandler(request: VNRequest, error: Error?) {
    guard let observations = request.results else {print("no result"); return}

    let result = observations.map({$0 as? VNTextObservation})
    if result.isEmpty {
        return
    }

    textObservations = result as! [VNTextObservation]
}

func recognizeTexts(cvPixelBuffer: CVPixelBuffer) {
    var ciImage = CIImage(cvPixelBuffer: self.currentBuffer!)
    let transform = ciImage.orientationTransform(for: CGImagePropertyOrientation(rawValue: 6)!)
    ciImage = ciImage.transformed(by: transform)
    let size = ciImage.extent.size
    
    var keywords = ""
    for textObservation in self.textObservations {
        guard let rects = textObservation.characterBoxes else {
        continue
        }
        let (imageRect, xMin, xMax, yMin, yMax) = createImageRect(rects: rects, size: size)
        
        var text = runOCRonImage(imageRect: imageRect, ciImage: ciImage, tesseract: tesseract)
        keywords += " \(text)"
    }
    
    createVideoAnchor()
    textObservations.removeAll()
}

func runOCRonImage(imageRect: CGRect, ciImage: CIImage, tesseract: G8Tesseract) -> String {
    let context = CIContext(options: nil)
    guard let cgImage = context.createCGImage(ciImage, from: imageRect) else {
        return ""
    }
    let uiImage = preprocessImage(image: UIImage(cgImage: cgImage))
    tesseract.image = uiImage
    tesseract.recognize()
    guard let text = tesseract.recognizedText else {
        return ""
    }
    return text.trimmingCharacters(in: CharacterSet.newlines)
}

func preprocessImage(image: UIImage) -> UIImage {
    var resultImage = image.fixOrientation().g8_grayScale()?.g8_blackAndWhite()
    resultImage = resultImage?.resizeVI(size: CGSize(width: image.size.width * 3, height: image.size.height * 3))!
    return resultImage!
}

// Create anchor using the camera's current position
if let currentFrame = sceneView.session.currentFrame {
    self.cinemaFrame = currentFrame
    
    var translation = matrix_identity_float4x4
    translation.columns.3.z = -1.5
    let transform = matrix_multiply((cinemaFrame?.camera.transform)!, translation)

    let anchor = ARAnchor(transform: transform)
    sceneView.session.add(anchor: anchor)
}

func addVideoToSCNNode(url: String, node: SCNNode) {
    let videoNode = SKVideoNode(url: URL(string: url)!)

    let skScene = SKScene(size: CGSize(width: 1280, height: 720))
    skScene.addChild(videoNode)

    videoNode.position = CGPoint(x: skScene.size.width/2, y: skScene.size.height/2)
    videoNode.size = skScene.size

    let tvPlane = SCNPlane(width: 1.0, height: 0.5625)
    tvPlane.firstMaterial?.diffuse.contents = skScene
    tvPlane.firstMaterial?.isDoubleSided = true

    let tvPlaneNode = SCNNode(geometry: tvPlane)
    tvPlaneNode.eulerAngles = SCNVector3(0,GLKMathDegreesToRadians(180),GLKMathDegreesToRadians(-90))
    tvPlaneNode.opacity = 0.9

    videoNode.play()

    node.addChildNode(tvPlaneNode)
}