ARCore: vad är det, möjligheter och teknik för förstärkt verklighet

Vad är ARCore?

ARCore — är Googles plattform för förstärkt verklighet, tillkännagiven 2018 som efterträdare till Project Tango i ett lättare och mer tillgängligt format. Till skillnad från Tango, som krävde specialiserade djup sensorer, fungerar ARCore på vanliga Android-smartphones med endast kameran och tröghetssensorerna (IMU).

ARCore använder tre nyckelteknologier: Motion Tracking för att spåra enhetens position, Environmental Understanding för att upptäcka horisontella och vertikala plan och Light Estimation för att anpassa belysningen av virtuella objekt till den verkliga miljön. Dessa tre teknologier gör det möjligt att placera AR-objekt som ser naturliga ut på vilken yta som helst.

Enligt Google I/O 2024 stöds ARCore på över 1 miljard Android-enheter, inklusive smartphones från Samsung, Xiaomi, Huawei, OnePlus, Google Pixel och andra. Plattformen är integrerad med Google Play Services for AR, vilket gör det möjligt att uppdatera ARCore via Google Play Store oberoende av Android-versionen.

ARCore utveckling

Under sex versioner har ARCore genomgått en betydande utveckling: ARCore 1.0 — grundläggande spårning och planigenkänning; ARCore 1.2 — vertikala plan och Augmented Images; ARCore 1.7 — Cloud Anchors för fleranvändarsessioner; ARCore 1.10 — Augmented Faces för att spåra ansiktsuttryck.

ARCore 1.20+ innehåller Scene Semantic Understanding — igenkänning av objektkategorier (golv, tak, vägg, möbel, växt, dörr) via TensorFlow Lite ML-modell på enheten. Street View Geometry API möjliggör användning av Google Street View djupkartor för AR-navigering utomhus.

// Initiera ARCore-session
val session = Session(context)
val config = Config(session)
config.lightEstimationMode =
    Config.LightEstimationMode.ENVIRONMENTAL_HDR
config.planeFindingMode =
    Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL
session.configure(config)

// Bearbeta bildruta
val frame = session.update()
val pointCloud = frame.acquirePointCloud()
val planes = session.getAllTrackables(
    Plane::class.java
)

Hur ARCore fungerar

ARCore använder ett hybridt tillvägagångssätt: IMU (tröghetsmätningsenhet) förutsäger enhetens position med hög frekvens (upp till 1000 Hz), och visuell odometri korrigerar fel baserat på analys av karakteristiska punkter från kameran med en frekvens på 30–60 Hz. Detta tillvägagångssätt ger en spårningsnoggrannhet på cirka 1–2 centimeter under stationära förhållanden.

Environmental Understanding-processen fungerar i tre steg: först hittar ARCore karakteristiska punkter (feature points) i kamerabilden, sedan identifierar den kluster av punkter som ligger på samma plan och approximerar dem till en polygon. Efter planigenkänning skapar ARCore ett Trackable-objekt av typen Plane som uppdateras när nya bildrutor kommer in.

Enligt Google upptäcker ARCore ett plan på 10x10 centimeter på ett avstånd av upp till 1 meter från kameran. För medelstora rum (rum på 20 m²) tar fullständig skanning av plan cirka 2–4 sekunder. Vid användning av Depth API med stöd för ToF-sensor ökar igenkänningsnoggrannheten med 40%.

Depth API och Scene Mesh

Depth API — ARCore-teknik som bygger en djupkarta över scenen baserat på stereoanalys av kamerabilden. På enheter med ToF-sensor (Time-of-Flight) erhålls djupkartan omedelbart med en noggrannhet på upp till 2 cm. På enheter utan djup sensor använder Depth API maskininlärning för att uppskatta djup från en enda bildruta, vilket ger en noggrannhet på cirka 10 cm.

Scene Mesh — ett tredimensionellt nätverk av miljön som ARCore bygger i realtid. Nätverket används för kollisionsfysik, ocklusion av virtuella objekt och applicering av skuggor. Scene Mesh är tillgängligt på enheter med OpenGL ES 3.1 och Depth API-stöd och omfattar upp till 500 tusen polygoner per bildruta.

// Hämta djupkarta
val depthImage = frame.acquireDepthImage16Bits()

// Placera objekt på identifierat plan
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 och ARKit: jämförelse

Även om ARCore och ARKit löser samma uppgifter — positionsspårning, planigenkänning och ljusbedömning — skiljer sig deras tillvägagångssätt och ekosystem. ARCore prioriterar plattformsoberoende och kompatibilitet, medan ARKit använder djup integration med Apple-hårdvara.

Viktiga skillnader: ARCore fungerar på Android och iOS via ARCore SDK, ARKit — endast på iOS. ARCore använder Cloud Anchors för synkronisering via Firebase, ARKit — ARWorldMap för direkt utbyte mellan enheter. ARCore med Depth API stöder ToF-sensorer, ARKit med LiDAR — laserskanning med en noggrannhet på upp till 3 cm.

Enligt Googles jämförande tester 2024 är spårningsnoggrannheten för ARCore på enheter med gyroskop och ToF-sensor jämförbar med ARKit på iPhone med LiDAR — felet överstiger inte 2 cm på ett avstånd av 2 meter. På enheter utan ToF ligger ARCore efter ARKit när det gäller initieringshastighet: 3 sekunder jämfört med 0,5 sekunder.

Valet mellan ARCore och ARKit beror på målgruppen: om appen endast är avsedd för iOS — ger ARKit bättre prestanda och tillgång till exklusiva LiDAR-funktioner. Om stöd för båda plattformarna behövs — gör ARCore med ARCore iOS SDK det möjligt att använda en enhetlig kodbas med minimala plattformsskillnader, om än med förlust av vissa hårdvarufunktioner för varje plattform.

Integrera ARCore i applikationen

ARCore-integration börjar med att lägga till beroendet Google Play Services for AR i build.gradle: com.google.ar:core. Applikationen bör kontrollera tillgängligheten av ARCore på enheten via ArCoreApk.checkAvailability() — om ARCore inte är installerat, föreslå användaren att installera det från Google Play Store.

Grundläggande ARCore-projekt inkluderar: skapa Session och Config, konfigurera SurfaceView för att visa kameran, starta sessionen via session.resume() och bearbeta bildrutor via session.update(). För rendering av 3D-objekt används Sceneform SDK (Googles bibliotek baserat på Filament) eller Unity/Unreal för komplexa scener.

Google rekommenderar Sceneform för Kotlin-appar — det tillhandahåller färdiga komponenter: ModelRenderable för att ladda 3D-modeller (OBJ, glTF, FBX), ViewRenderable för att bädda in Android View i AR-scenen och MotionEvent för att hantera beröringar. Sceneform hanterar automatiskt AR-sessionens livscykel och frigöring av resurser.

Hantera spårningsfel

ARCore kan förlora spårning vid otillräcklig belysning, enhetliga ytor eller snabba rörelser av enheten. Spårningsstatus är tillgänglig via frame.getTrackingState() — värdena TRACKING, PAUSED och STOPPED. Vid övergång till PAUSED rekommenderas att pausa renderingen och visa rekommendationer för användaren: “Flytta enheten långsammare” eller “Gå till en ljusare plats”.

För automatisk återhämtning efter fel stöder ARCore relokalisering baserat på en sparad karta över karakteristiska punkter. Utvecklaren kan spara kartan via session.serialize() och återställa den via session.deserialize() — detta är användbart för långvariga AR-upplevelser där användaren återvänder till samma fysiska utrymme. Återställning av kartan tar 1–2 sekunder, förutsatt att miljön inte har förändrats avsevärt.

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