[Anderson Paraibano]

A Realidade Aumentada (RA) é uma tecnologia em constante evolução que tem revolucionado a forma como interagimos com o mundo digital. Com a crescente popularidade dos dispositivos móveis e o desenvolvimento de frameworks como o ARKit da Apple, os desenvolvedores têm sido capazes de criar experiências imersivas e envolventes para os usuários.

O ARKit é um framework para iOS que permite aos desenvolvedores criar aplicativos de Realidade Aumentada de alta qualidade de forma rápida e eficiente. Ele oferece uma ampla gama de recursos e funcionalidades, incluindo o rastreamento de faces através da classe ARFaceAnchor.

Uma das tarefas comuns ao trabalhar com ARFaceAnchor é a aplicação de efeitos visuais, como filtros, em áreas específicas do rosto. Neste artigo, vamos explorar como aplicar o filtro CIFilter a um vértice específico de um ARFaceAnchor usando o ARKit.

O primeiro passo é configurar uma sessão de AR e rastrear a face do usuário. Para isso, é necessário importar as bibliotecas necessárias e criar uma sessão AR.

swift
Copy code
import UIKit
import ARKit

class ViewController: UIViewController, ARSCNViewDelegate {

@IBOutlet var sceneView: ARSCNView!

override func viewDidLoad() {
super.viewDidLoad()

let configuration = ARFaceTrackingConfiguration()
sceneView.session.run(configuration)
sceneView.delegate = self
}

override func viewWillAppear(_ animated: Bool) {
super.viewWillAppear(animated)
let configuration = ARFaceTrackingConfiguration()
sceneView.session.run(configuration)
}

override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
sceneView.session.pause()
}

func renderer(_ renderer: SCNSceneRenderer, nodeFor anchor: ARAnchor) -> SCNNode? {
let faceMesh = ARSCNFaceGeometry(device: sceneView.device!)
let node = SCNNode(geometry: faceMesh)
return node
}
}
Agora que temos a face rastreada e representada por um ARSCNFaceGeometry, podemos aplicar um filtro a um vértice específico desse objeto. Vamos supor que queremos aplicar um filtro de cor vermelha ao vértice do nariz. Podemos fazer isso usando a classe CIFilter.

swift
Copy code
func renderer(_ renderer: SCNSceneRenderer, didUpdate node: SCNNode, for anchor: ARAnchor) {
if let faceAnchor = anchor as? ARFaceAnchor, let faceGeometry = node.geometry as? ARSCNFaceGeometry {
let noseIndex = 7 // Índice do vértice do nariz no objeto ARSCNFaceGeometry
let nosePosition = faceGeometry.vertices[noseIndex]

let filter = CIFilter(name: “CIColorControls”)!
filter.setValue(1.0, forKey: “inputSaturation”)
filter.setValue(2.0, forKey: “inputBrightness”)
filter.setValue(3.0, forKey: “inputContrast”)

let colorFilter = CIFilter(name: “CIColorMatrix”)!
colorFilter.setValue(CIVector(x: 1.0, y: 0.0, z: 0.0, w: 0.0), forKey: “inputRVector”)
colorFilter.setValue(CIVector(x: 0.0, y: 1.0, z: 0.0, w: 0.0), forKey: “inputGVector”)
colorFilter.setValue(CIVector(x: 0.0, y: 0.0, z: 1.0, w: 0.0), forKey: “inputBVector”)
colorFilter.setValue(CIVector(x: 0.0, y: 0.0, z: 0.0, w: 1.0), forKey: “inputAVector”)

let outputImage = CIImage(cvPixelBuffer: faceGeometry.fillMeshWithColors(color: UIColor.red.cgColor, at: noseIndex))
filter.setValue(outputImage, forKey: kCIInputImageKey)
colorFilter.setValue(filter.outputImage, forKey: kCIInputImageKey)

let context = CIContext()
if let output = colorFilter.outputImage, let cgImage = context.createCGImage(output, from: output.extent) {
let material = SCNMaterial()
material.diffuse.contents = UIImage(cgImage: cgImage)
faceGeometry.firstMaterial = material
}
}
}
Nesse código, a função renderer(_:didUpdate:for:) é chamada toda vez que houver uma atualização no ARFaceAnchor. Primeiro, obtemos a posição do vértice do nariz (neste exemplo, o índice 7 é usado como uma aproximação). Em seguida, configuramos um filtro CIFilter para ajustar as configurações de cor e um filtro de matriz de cor para aplicar a cor vermelha. Finalmente, aplicamos a imagem filtrada ao material da geometria do rosto.

Este é apenas um exemplo básico de como aplicar um filtro a um vértice específico de um ARFaceAnchor usando o ARKit. Existem muitas outras possibilidades e efeitos visuais que podem ser explorados, permitindo aos desenvolvedores criar experiências de Realidade Aumentada únicas e imersivas.

Em conclusão, o ARKit oferece um conjunto poderoso de ferramentas para criar aplicativos de Realidade Aumentada no iOS de forma rápida e eficiente. A capacidade de aplicar filtros a vértices específicos de um ARFaceAnchor abre um mundo de possibilidades para criar experiências de RA altamente personalizadas e envolventes.

[Autor]

Posts