ARCore: cos'è, funzionalità e tecnologia della realtà aumentata

Cos'è ARCore?

ARCore è la piattaforma di realtà aumentata di Google, annunciata nel 2018 come successore di Project Tango in un formato più leggero e accessibile. A differenza di Tango, che richiedeva sensori di profondità specializzati, ARCore funziona su smartphone Android standard utilizzando solo la fotocamera e i sensori inerziali (IMU).

ARCore utilizza tre tecnologie chiave: Motion Tracking per tracciare la posizione del dispositivo, Environmental Understanding per rilevare piani orizzontali e verticali e Light Estimation per regolare l'illuminazione degli oggetti virtuali in base all'ambiente reale. Queste tre tecnologie consentono di posizionare oggetti AR che appaiono naturali su qualsiasi superficie.

Secondo Google I/O 2024, ARCore è supportato su oltre 1 miliardo di dispositivi Android, inclusi smartphone Samsung, Xiaomi, Huawei, OnePlus, Google Pixel e altri. La piattaforma è integrata con Google Play Services for AR, che consente di aggiornare ARCore tramite Google Play Store indipendentemente dalla versione di Android.

Evoluzione di ARCore

Attraverso sei versioni, ARCore ha subito un'evoluzione significativa: ARCore 1.0 — tracciamento di base e rilevamento dei piani; ARCore 1.2 — piani verticali e Augmented Images; ARCore 1.7 — Cloud Anchors per sessioni multiplayer; ARCore 1.10 — Augmented Faces per il tracciamento delle espressioni facciali.

ARCore 1.20+ include Scene Semantic Understanding — riconoscimento di categorie di oggetti (pavimento, soffitto, parete, mobile, pianta, porta) tramite un modello ML TensorFlow Lite sul dispositivo. L'API Street View Geometry consente di utilizzare le mappe di profondità di Google Street View per la navigazione AR all'aperto.

// Inizializzazione di una sessione 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)

// Elaborazione del fotogramma
val frame = session.update()
val pointCloud = frame.acquirePointCloud()
val planes = session.getAllTrackables(
    Plane::class.java
)

Come funziona ARCore

ARCore utilizza un approccio ibrido: l'IMU (unità di misura inerziale) prevede la posizione del dispositivo ad alta frequenza (fino a 1000 Hz), mentre l'odometria visiva corregge gli errori basandosi sull'analisi dei punti caratteristici della fotocamera a 30–60 Hz. Questo approccio fornisce una precisione di tracciamento di circa 1–2 centimetri in condizioni stazionarie.

Il processo di Environmental Understanding funziona in tre fasi: prima, ARCore trova punti caratteristici nell'immagine della fotocamera, poi identifica gruppi di punti che giacciono sullo stesso piano e li approssima in un poligono. Dopo il riconoscimento del piano, ARCore crea un oggetto Trackable di tipo Plane che si aggiorna man mano che vengono ricevuti nuovi fotogrammi.

Secondo Google, ARCore rileva un piano di 10x10 centimetri a una distanza fino a 1 metro dalla fotocamera. Per stanze di medie dimensioni (20 m²), la scansione completa dei piani richiede circa 2–4 secondi. Utilizzando Depth API con supporto del sensore ToF, la precisione del riconoscimento migliora del 40%.

Depth API e Scene Mesh

Depth API è una tecnologia ARCore che costruisce una mappa di profondità della scena basata sull'analisi stereo dell'immagine della fotocamera. Sui dispositivi con sensore ToF (Time-of-Flight), la mappa di profondità viene ottenuta istantaneamente con una precisione fino a 2 cm. Sui dispositivi senza sensore di profondità, Depth API utilizza l'apprendimento automatico per stimare la profondità da un singolo fotogramma, fornendo una precisione di circa 10 cm.

Scene Mesh è una maglia tridimensionale dell'ambiente che ARCore costruisce in tempo reale. La maglia viene utilizzata per la fisica delle collisioni, l'occlusione degli oggetti virtuali e il rendering delle ombre. Scene Mesh è disponibile su dispositivi con OpenGL ES 3.1 e supporto Depth API, generando fino a 500mila poligoni per fotogramma.

// Ottenimento della mappa di profondità
val depthImage = frame.acquireDepthImage16Bits()

// Posizionamento di un oggetto su un piano rilevato
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: confronto

Sebbene ARCore e ARKit risolvano gli stessi compiti — tracciamento della posizione, rilevamento dei piani e stima dell'illuminazione — i loro approcci ed ecosistemi differiscono. ARCore privilegia la compatibilità multipiattaforma, mentre ARKit utilizza un'integrazione profonda con l'hardware Apple.

Differenze principali: ARCore funziona su Android e iOS tramite ARCore SDK, mentre ARKit funziona solo su iOS. ARCore utilizza Cloud Anchors per la sincronizzazione tramite Firebase, mentre ARKit utilizza ARWorldMap per lo scambio diretto tra dispositivi. ARCore con Depth API supporta sensori ToF, mentre ARKit con LiDAR fornisce scansione laser con una precisione fino a 3 cm.

Secondo i test comparativi di Google 2024, la precisione di tracciamento di ARCore su dispositivi con giroscopio e sensore ToF è paragonabile a quella di ARKit su iPhone con LiDAR — l'errore non supera i 2 cm a una distanza di 2 metri. Su dispositivi senza ToF, ARCore è in ritardo rispetto ad ARKit nella velocità di inizializzazione: 3 secondi contro 0,5 secondi.

La scelta tra ARCore e ARKit dipende dal pubblico di destinazione: se l'app è solo per iOS, ARKit offre prestazioni migliori e accesso a funzionalità esclusive del LiDAR. Se è necessario il supporto multipiattaforma, ARCore con l'SDK ArcoreiOS consente di utilizzare un'unica base di codice con differenze minime tra le piattaforme, sebbene con la perdita di alcune capacità hardware specifiche di ciascuna piattaforma.

Integrazione di ARCore in un'app

L'integrazione di ARCore inizia con l'aggiunta della dipendenza di Google Play Services for AR in build.gradle: com.google.ar:core. L'app deve verificare la disponibilità di ARCore sul dispositivo tramite ArCoreApk.checkAvailability() — se ARCore non è installato, invitare l'utente a installarlo dal Google Play Store.

Un progetto ARCore di base include: creazione di una Session e Config, configurazione di un SurfaceView per la visualizzazione della fotocamera, avvio della sessione tramite session.resume() ed elaborazione dei fotogrammi tramite session.update(). Per il rendering di oggetti 3D viene utilizzato Sceneform SDK (libreria Google basata su Filament) o Unity/Unreal per scene complesse.

Google raccomanda Sceneform per le app Kotlin — fornisce componenti pronti: ModelRenderable per caricare modelli 3D (OBJ, glTF, FBX), ViewRenderable per incorporare viste Android in una scena AR e MotionEvent per la gestione del tocco. Sceneform gestisce automaticamente il ciclo di vita della sessione AR e la liberazione delle risorse.

Gestione dei fallimenti di tracciamento

ARCore può perdere il tracciamento in condizioni di scarsa illuminazione, superfici uniformi o movimenti rapidi del dispositivo. Lo stato di tracciamento è disponibile tramite frame.getTrackingState() — i valori sono TRACKING, PAUSED e STOPPED. Quando si passa a PAUSED, si consiglia di mettere in pausa il rendering e mostrare all'utente indicazioni: “Muovi il dispositivo più lentamente” o “Spostati in un luogo più illuminato.”

Per il recupero automatico dopo un guasto, ARCore supporta la rilocalizzazione basata su una mappa salvata di punti caratteristici. Lo sviluppatore può salvare la mappa tramite session.serialize() e ripristinarla tramite session.deserialize() — utile per esperienze AR di lunga durata in cui l'utente ritorna nello stesso spazio fisico. Il ripristino della mappa richiede 1–2 secondi, a condizione che l'ambiente non sia cambiato in modo significativo.

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()
            }
        }
    }
}