giln

// MARK: - ARSCNViewDelegate

func renderer(_: SCNSceneRenderer, nodeFor anchor: ARAnchor) -> SCNNode? {
    guard let _ = anchor as? ARPlaneAnchor else { return nil }

    // We return a special type of SCNNode for ARPlaneAnchors
    return PlaneNode()
}

func renderer(_: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {

giln

import ARKit
import SceneKit

public class PlaneNode: SCNNode {

    // MARK: - Public functions

    public func update(from planeAnchor: ARPlaneAnchor) {
        // We need to create a new geometry each time because it does not seem to update correctly for physics
        guard let device = MTLCreateSystemDefaultDevice(),

giln

// Create a session configuration
let configuration = ARWorldTrackingConfiguration()

// Enable Horizontal plane detection
configuration.planeDetection = .horizontal

// We want to receive the frames from the video
sceneView.session.delegate = self

// Run the session with the configuration

giln

// MARK: - Private functions

let handDetector = HandDetector()

private func startDetection() {
    // To avoid force unwrap in VNImageRequestHandler
    guard let buffer = currentBuffer else { return }

    handDetector.performDetection(inputBuffer: buffer) { outputBuffer, _ in
        // Here we are on a background thread

giln

var previewView = UIImageView()

// MARK: - Lifecycle

override func loadView() {
    super.loadView()

    view = sceneView

    // Create a session configuration

giln

import CoreML
import Vision

public class HandDetector {
    // MARK: - Variables

    private let visionQueue = DispatchQueue(label: "com.viseo.ARML.visionqueue")

    private lazy var predictionRequest: VNCoreMLRequest = {
        // Load the ML model through its generated class and create a Vision request for it.

giln

let visionQueue = DispatchQueue(label: "com.viseo.ARML.visionqueue")

private func startDetection() {
    // To avoid force unwrap in VNImageRequestHandler
    guard let buffer = currentBuffer else { return }

    // Right orientation because the pixel data for image captured by an iOS device is encoded in the camera sensor's native landscape orientation
    let requestHandler = VNImageRequestHandler(cvPixelBuffer: buffer, orientation: .right)

    // We perform our CoreML Requests asynchronously.

giln

private lazy var predictionRequest: VNCoreMLRequest = {
    // Load the ML model through its generated class and create a Vision request for it.
    do {
        let model = try VNCoreMLModel(for: HandModel().model)
        let request = VNCoreMLRequest(model: model)

        // This setting determines if images are scaled or cropped to fit our 224x224 input size. Here we try scaleFill so we don't cut part of the image.
        request.imageCropAndScaleOption = VNImageCropAndScaleOption.scaleFill
        return request
    } catch {

giln

// MARK: - ARSessionDelegate

var currentBuffer: CVPixelBuffer?

func session(_: ARSession, didUpdate frame: ARFrame) {
    // We return early if currentBuffer is not nil or the tracking state of camera is not normal
    guard currentBuffer == nil, case .normal = frame.camera.trackingState else {
        return
    }

giln

import ARKit

class ARViewController: UIViewController, ARSessionDelegate {
    // MARK: - Variables

    let sceneView = ARSCNView()

    // MARK: - Lifecycle

    override func loadView() {