ARCore: o que é, recursos e tecnologia de realidade aumentada

O que é ARCore?

ARCore é a plataforma de realidade aumentada da Google, anunciada em 2018 como sucessora do Project Tango em um formato mais leve e acessível. Ao contrário do Tango, que exigia sensores de profundidade especializados, o ARCore funciona em smartphones Android padrão usando apenas a câmera e os sensores inerciais (IMU).

O ARCore usa três tecnologias principais: Motion Tracking para rastrear a posição do dispositivo, Environmental Understanding para detectar planos horizontais e verticais, e Light Estimation para ajustar a iluminação de objetos virtuais ao ambiente real. Essas três tecnologias permitem posicionar objetos AR que parecem naturais em qualquer superfície.

De acordo com o Google I/O 2024, o ARCore é suportado em mais de 1 bilhão de dispositivos Android, incluindo smartphones Samsung, Xiaomi, Huawei, OnePlus, Google Pixel e outros. A plataforma está integrada ao Google Play Services for AR, permitindo atualizar o ARCore via Google Play Store independentemente da versão do Android.

Evolução do ARCore

Ao longo de seis versões, o ARCore passou por uma evolução significativa: ARCore 1.0 — rastreamento básico e detecção de planos; ARCore 1.2 — planos verticais e Augmented Images; ARCore 1.7 — Cloud Anchors para sessões multijogador; ARCore 1.10 — Augmented Faces para rastreamento de expressões faciais.

ARCore 1.20+ inclui Scene Semantic Understanding — reconhecimento de categorias de objetos (chão, teto, parede, móvel, planta, porta) através de um modelo ML TensorFlow Lite no dispositivo. A API Street View Geometry permite usar mapas de profundidade do Google Street View para navegação AR ao ar livre.

// Inicializando uma sessão ARCore
val session = Session(context)
val config = Config(session)
config.lightEstimationMode =
    Config.LightEstimationMode.ENVIRONMENTAL_HDR
config.planeFindingMode =
    Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL
session.configure(config)

// Processamento de quadro
val frame = session.update()
val pointCloud = frame.acquirePointCloud()
val planes = session.getAllTrackables(
    Plane::class.java
)

Como o ARCore funciona

O ARCore usa uma abordagem híbrida: a IMU (Unidade de Medição Inercial) prevê a posição do dispositivo em alta frequência (até 1000 Hz), enquanto a odometria visual corrige erros com base na análise de pontos característicos da câmera a 30–60 Hz. Esta abordagem fornece precisão de rastreamento de aproximadamente 1–2 centímetros em condições estacionárias.

O processo de Environmental Understanding funciona em três etapas: primeiro, o ARCore encontra pontos característicos na imagem da câmera, depois identifica agrupamentos de pontos no mesmo plano e os aproxima para um polígono. Após o reconhecimento do plano, o ARCore cria um objeto Trackable do tipo Plane que é atualizado à medida que novos quadros são recebidos.

Segundo a Google, o ARCore detecta um plano de 10x10 centímetros a uma distância de até 1 metro da câmera. Para salas médias (20 m²), a digitalização completa de planos leva cerca de 2–4 segundos. Ao usar a Depth API com suporte a sensor ToF, a precisão do reconhecimento melhora em 40%.

Depth API e Scene Mesh

Depth API é uma tecnologia ARCore que constrói um mapa de profundidade da cena com base na análise estéreo da imagem da câmera. Em dispositivos com sensor ToF (Time-of-Flight), o mapa de profundidade é obtido instantaneamente com precisão de até 2 cm. Em dispositivos sem sensor de profundidade, a Depth API usa aprendizado de máquina para estimar a profundidade a partir de um único quadro, fornecendo precisão de cerca de 10 cm.

Scene Mesh é uma malha tridimensional do ambiente que o ARCore constrói em tempo real. A malha é usada para física de colisões, oclusão de objetos virtuais e renderização de sombras. O Scene Mesh está disponível em dispositivos com OpenGL ES 3.1 e suporte à Depth API, gerando até 500 mil polígonos por quadro.

// Obtendo o mapa de profundidade
val depthImage = frame.acquireDepthImage16Bits()

// Colocando um objeto em um plano detectado
val hitResult = frame.hitTest(x, y)
    .firstOrNull { it.trackable is Plane }

hitResult?.let { result ->
    val anchor = session.createAnchor(
        result.hitPose
    )
    val model = ModelRenderable.builder()
        .setSourceId(R.raw.my_model)
        .build()
        .exceptionally { null }

    AnchorNode(anchor).apply {
        this.renderable = model.get()
    }
}

ARCore vs ARKit: comparação

Embora o ARCore e o ARKit resolvam as mesmas tarefas — rastreamento de posição, detecção de planos e estimativa de iluminação — suas abordagens e ecossistemas diferem. O ARCore prioriza a compatibilidade multiplataforma, enquanto o ARKit usa integração profunda com o hardware da Apple.

Principais diferenças: o ARCore funciona no Android e iOS através do ARCore SDK, enquanto o ARKit funciona apenas no iOS. O ARCore usa Cloud Anchors para sincronização via Firebase, enquanto o ARKit usa ARWorldMap para troca direta entre dispositivos. O ARCore com Depth API suporta sensores ToF, enquanto o ARKit com LiDAR fornece digitalização a laser com precisão de até 3 cm.

De acordo com testes comparativos da Google 2024, a precisão de rastreamento do ARCore em dispositivos com giroscópio e sensor ToF é comparável ao ARKit no iPhone com LiDAR — o erro não excede 2 cm a uma distância de 2 metros. Em dispositivos sem ToF, o ARCore fica atrás do ARKit na velocidade de inicialização: 3 segundos contra 0,5 segundos.

A escolha entre ARCore e ARKit depende do público-alvo: se o aplicativo for apenas para iOS, o ARKit oferece melhor desempenho e acesso a recursos exclusivos do LiDAR. Se for necessário suporte multiplataforma, o ARCore com o SDK ArcoreiOS permite usar uma base de código única com diferenças mínimas entre plataformas, embora com perda de algumas capacidades de hardware específicas de cada plataforma.

Integrando ARCore em um aplicativo

A integração do ARCore começa com a adição da dependência do Google Play Services for AR no build.gradle: com.google.ar:core. O aplicativo deve verificar a disponibilidade do ARCore no dispositivo através de ArCoreApk.checkAvailability() — se o ARCore não estiver instalado, solicitar ao usuário que o instale da Google Play Store.

Um projeto básico de ARCore inclui: criar uma Session e Config, configurar um SurfaceView para exibição da câmera, iniciar a sessão via session.resume() e processar quadros via session.update(). Para renderização de objetos 3D, utiliza-se o Sceneform SDK (biblioteca da Google baseada em Filament) ou Unity/Unreal para cenas complexas.

A Google recomenda o Sceneform para aplicativos Kotlin — ele fornece componentes prontos: ModelRenderable para carregar modelos 3D (OBJ, glTF, FBX), ViewRenderable para incorporar visualizações Android em uma cena AR e MotionEvent para manipulação de toque. O Sceneform gerencia automaticamente o ciclo de vida da sessão AR e a liberação de recursos.

Tratamento de falhas de rastreamento

O ARCore pode perder o rastreamento em condições de pouca luz, superfícies uniformes ou movimentos rápidos do dispositivo. O estado de rastreamento está disponível através de frame.getTrackingState() — os valores são TRACKING, PAUSED e STOPPED. Ao transitar para PAUSED, recomenda-se pausar a renderização e mostrar orientações ao usuário: “Mova o dispositivo mais lentamente” ou “Vá para um local mais iluminado.”

Para recuperação automática após falha, o ARCore suporta relocalização com base em um mapa salvo de pontos característicos. O desenvolvedor pode salvar o mapa via session.serialize() e restaurá-lo via session.deserialize() — útil para experiências AR de longa duração onde o usuário retorna ao mesmo espaço físico. A restauração do mapa leva de 1 a 2 segundos, desde que o ambiente não tenha mudado significativamente.

class ARCoreActivity : AppCompatActivity() {

    private lateinit var session: Session

    override fun onResume() {
        super.onResume()
        when (ArCoreApk.getInstance()
            .checkAvailability(this)
        ) {
            ArCoreApk.Availability.SUPPORTED_INSTALLED -> {
                session = Session(this)
                session.resume()
            }
            else -> {
                showInstallPrompt()
            }
        }
    }
}