ARCore : qu'est-ce que c'est, fonctionnalités et technologie de réalité augmentée

Qu'est-ce que ARCore ?

ARCore est la plateforme de réalité augmentée de Google, annoncée en 2018 en tant que successeur de Project Tango dans un format plus léger et plus accessible. Contrairement à Tango, qui nécessitait des capteurs de profondeur spécialisés, ARCore fonctionne sur les smartphones Android standard en utilisant uniquement la caméra et les capteurs inertiels (IMU).

ARCore utilise trois technologies clés : Motion Tracking pour le suivi de la position de l'appareil, Environmental Understanding pour la détection des plans horizontaux et verticaux, et Light Estimation pour ajuster l'éclairage des objets virtuels à l'environnement réel. Ces trois technologies permettent de placer des objets AR qui semblent naturels sur n'importe quelle surface.

D'après Google I/O 2024, ARCore est pris en charge sur plus d'un milliard d'appareils Android, y compris les smartphones Samsung, Xiaomi, Huawei, OnePlus, Google Pixel et d'autres. La plateforme est intégrée à Google Play Services for AR, ce qui permet de mettre à jour ARCore via le Google Play Store indépendamment de la version d'Android.

Évolution d'ARCore

Au cours de six versions, ARCore a connu une évolution significative : ARCore 1.0 — suivi de base et détection de plans ; ARCore 1.2 — plans verticaux et Augmented Images ; ARCore 1.7 — Cloud Anchors pour les sessions multijoueurs ; ARCore 1.10 — Augmented Faces pour le suivi des expressions faciales.

ARCore 1.20+ inclut Scene Semantic Understanding — reconnaissance de catégories d'objets (sol, plafond, mur, meuble, plante, porte) via un modèle ML TensorFlow Lite sur l'appareil. L'API Street View Geometry permet d'utiliser les cartes de profondeur de Google Street View pour la navigation AR en extérieur.

// Initialisation d'une session 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)

// Traitement de l'image
val frame = session.update()
val pointCloud = frame.acquirePointCloud()
val planes = session.getAllTrackables(
    Plane::class.java
)

Comment fonctionne ARCore

ARCore utilise une approche hybride : l'IMU (unité de mesure inertielle) prédit la position de l'appareil à haute fréquence (jusqu'à 1000 Hz), tandis que l'odométrie visuelle corrige les erreurs en se basant sur l'analyse des points caractéristiques de la caméra à 30–60 Hz. Cette approche offre une précision de suivi d'environ 1–2 centimètres dans des conditions stationnaires.

Le processus d'Environmental Understanding fonctionne en trois étapes : d'abord, ARCore trouve des points caractéristiques dans l'image de la caméra, puis identifie des amas de points situés sur le même plan et les approxime en un polygone. Après la reconnaissance du plan, ARCore crée un objet Trackable de type Plane qui se met à jour au fur et à mesure que de nouvelles images sont reçues.

Selon Google, ARCore détecte un plan de 10x10 centimètres à une distance allant jusqu'à 1 mètre de la caméra. Pour les pièces de taille moyenne (20 m²), le balayage complet des plans prend environ 2 à 4 secondes. En utilisant l'API Depth avec le support du capteur ToF, la précision de la reconnaissance s'améliore de 40 %.

API Depth et Scene Mesh

Depth API est une technologie ARCore qui construit une carte de profondeur de la scène basée sur l'analyse stéréo de l'image de la caméra. Sur les appareils équipés d'un capteur ToF (Time-of-Flight), la carte de profondeur est obtenue instantanément avec une précision allant jusqu'à 2 cm. Sur les appareils sans capteur de profondeur, Depth API utilise l'apprentissage automatique pour estimer la profondeur à partir d'une seule image, offrant une précision d'environ 10 cm.

Scene Mesh est un maillage tridimensionnel de l'environnement qu'ARCore construit en temps réel. Le maillage est utilisé pour la physique des collisions, l'occlusion des objets virtuels et le rendu des ombres. Scene Mesh est disponible sur les appareils avec OpenGL ES 3.1 et le support de Depth API, générant jusqu'à 500 000 polygones par image.

// Obtention de la carte de profondeur
val depthImage = frame.acquireDepthImage16Bits()

// Placement d'un objet sur un plan détecté
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 : comparaison

Bien que ARCore et ARKit résolvent les mêmes tâches — suivi de position, détection de plans et estimation de l'éclairage — leurs approches et écosystèmes diffèrent. ARCore privilégie la compatibilité multiplateforme, tandis qu'ARKit utilise une intégration profonde avec le matériel Apple.

Principales différences : ARCore fonctionne sur Android et iOS via le SDK ARCore, tandis qu'ARKit ne fonctionne que sur iOS. ARCore utilise Cloud Anchors pour la synchronisation via Firebase, tandis qu'ARKit utilise ARWorldMap pour l'échange direct entre appareils. ARCore avec Depth API prend en charge les capteurs ToF, tandis qu'ARKit avec LiDAR offre un balayage laser avec une précision allant jusqu'à 3 cm.

Selon les tests comparatifs de Google 2024, la précision de suivi d'ARCore sur les appareils avec gyroscope et capteur ToF est comparable à celle d'ARKit sur iPhone avec LiDAR — l'erreur ne dépasse pas 2 cm à une distance de 2 mètres. Sur les appareils sans ToF, ARCore est en retard sur ARKit en vitesse d'initialisation : 3 secondes contre 0,5 seconde.

Le choix entre ARCore et ARKit dépend du public cible : si l'application est uniquement pour iOS, ARKit offre de meilleures performances et un accès aux fonctionnalités exclusives du LiDAR. Si une prise en charge multiplateforme est nécessaire, ARCore avec le SDK ArcoreiOS permet d'utiliser une base de code unique avec des différences minimales entre les plateformes, bien qu'avec une perte de certaines capacités matérielles spécifiques à chaque plateforme.

Intégration d'ARCore dans une application

L'intégration d'ARCore commence par l'ajout de la dépendance Google Play Services for AR dans build.gradle : com.google.ar:core. L'application doit vérifier la disponibilité d'ARCore sur l'appareil via ArCoreApk.checkAvailability() — si ARCore n'est pas installé, inviter l'utilisateur à l'installer depuis le Google Play Store.

Un projet ARCore de base comprend : la création d'une Session et d'une Config, la configuration d'un SurfaceView pour l'affichage de la caméra, le démarrage de la session via session.resume() et le traitement des images via session.update(). Pour le rendu d'objets 3D, on utilise le SDK Sceneform (bibliothèque Google basée sur Filament) ou Unity/Unreal pour les scènes complexes.

Google recommande Sceneform pour les applications Kotlin — il fournit des composants prêts à l'emploi : ModelRenderable pour charger des modèles 3D (OBJ, glTF, FBX), ViewRenderable pour intégrer des vues Android dans une scène AR et MotionEvent pour la gestion des touches. Sceneform gère automatiquement le cycle de vie de la session AR et la libération des ressources.

Gestion des pannes de suivi

ARCore peut perdre le suivi en cas de faible éclairage, de surfaces uniformes ou de mouvements rapides de l'appareil. L'état du suivi est disponible via frame.getTrackingState() — les valeurs sont TRACKING, PAUSED et STOPPED. Lors du passage à PAUSED, il est recommandé de mettre le rendu en pause et d'afficher des conseils à l'utilisateur : « Déplacez l'appareil plus lentement » ou « Rendez-vous dans un endroit plus éclairé. »

Pour une récupération automatique après une panne, ARCore prend en charge la relocalisation basée sur une carte sauvegardée de points caractéristiques. Le développeur peut sauvegarder la carte via session.serialize() et la restaurer via session.deserialize() — utile pour les expériences AR de longue durée où l'utilisateur revient dans le même espace physique. La restauration de la carte prend 1 à 2 secondes, à condition que l'environnement n'ait pas changé de manière significative.

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