ARCore: ano ito, mga kakayahan at teknolohiya ng augmented reality

Ano ang ARCore?

ARCore — ay ang augmented reality platform ng Google, inanunsyo noong 2018 bilang kahalili ng Project Tango sa isang mas magaan at mas accessible na format. Hindi tulad ng Tango na nangangailangan ng mga espesyal na depth sensor, gumagana ang ARCore sa mga standard na Android smartphone gamit lamang ang camera at inertial sensors (IMU).

Gumagamit ang ARCore ng tatlong pangunahing teknolohiya: Motion Tracking para subaybayan ang posisyon ng device, Environmental Understanding para makita ang mga pahalang at patayong eroplano at Light Estimation para i-adjust ang ilaw ng mga virtual na bagay sa totoong kapaligiran. Ang tatlong teknolohiyang ito ay nagpapahintulot sa paglalagay ng AR objects na mukhang natural sa anumang surface.

Ayon sa Google I/O 2024, ang ARCore ay sinusuportahan sa mahigit 1 bilyong Android device, kabilang ang Samsung, Xiaomi, Huawei, OnePlus, Google Pixel at iba pang smartphone. Ang platform ay integrated sa Google Play Services for AR na nagpapahintulot sa pag-update ng ARCore sa pamamagitan ng Google Play Store nang hiwalay sa bersyon ng Android.

Ebolusyon ng ARCore

Sa loob ng anim na bersyon, ang ARCore ay sumailalim sa makabuluhang ebolusyon: ARCore 1.0 — pangunahing pagsubaybay at pagkilala ng eroplano; ARCore 1.2 — patayong eroplano at Augmented Images; ARCore 1.7 — Cloud Anchors para sa multi-user sessions; ARCore 1.10 — Augmented Faces para sa pagsubaybay sa ekspresyon ng mukha.

ARCore 1.20+ ay may kasamang Scene Semantic Understanding — pagkilala sa mga kategorya ng bagay (sahig, kisame, dingding, kasangkapan, halaman, pinto) sa pamamagitan ng TensorFlow Lite ML model sa device. Ang Street View Geometry API ay nagpapahintulot sa paggamit ng Google Street View depth maps para sa AR navigation sa labas.

// Pagsisimula ng 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)

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

Paano gumagana ang ARCore

ARCore ay gumagamit ng hybrid approach: ang IMU (inertial measurement unit) ay hinuhulaan ang posisyon ng device na may mataas na frequency (hanggang 1000 Hz), at ang visual odometry ay nagwawasto ng mga error batay sa pagsusuri ng mga feature points mula sa camera na may frequency na 30–60 Hz. Ang approach na ito ay nagbibigay ng tracking accuracy na humigit-kumulang 1–2 sentimetro sa mga nakatigil na kondisyon.

Ang proseso ng Environmental Understanding ay gumagana sa tatlong yugto: una, hinahanap ng ARCore ang mga feature points sa imahe ng camera, pagkatapos ay tinutukoy ang mga kumpol ng mga punto na nasa parehong eroplano at pinapalapit ang mga ito sa isang polygon. Pagkatapos makilala ang eroplano, lumilikha ang ARCore ng Trackable object na uri ng Plane na naa-update habang dumarating ang mga bagong frame.

Ayon sa Google, tinutukoy ng ARCore ang isang eroplano na may sukat na 10x10 sentimetro sa layo na hanggang 1 metro mula sa camera. Para sa katamtamang laki ng mga kuwarto (kuwarto na 20 m²) ang buong pag-scan ng mga eroplano ay tumatagal ng mga 2–4 na segundo. Kapag gumagamit ng Depth API na may suporta sa ToF sensor, ang accuracy ng pagkilala ay tumataas ng 40%.

Depth API at Scene Mesh

Depth API — teknolohiya ng ARCore na bumubuo ng depth map ng scene batay sa stereo analysis ng imahe ng camera. Sa mga device na may ToF sensor (Time-of-Flight) ang depth map ay nakukuha agad na may accuracy na hanggang 2 cm. Sa mga device na walang depth sensor, ang Depth API ay gumagamit ng machine learning para tantyahin ang lalim mula sa isang frame, na nagbibigay ng accuracy na humigit-kumulang 10 cm.

Scene Mesh — isang three-dimensional na network ng kapaligiran na binuo ng ARCore sa real-time. Ang network ay ginagamit para sa collision physics, occlusion ng virtual objects at paglalagay ng mga anino. Ang Scene Mesh ay available sa mga device na may OpenGL ES 3.1 at suporta sa Depth API, sumasaklaw ng hanggang 500 libong polygon bawat frame.

// Pagkuha ng depth map
val depthImage = frame.acquireDepthImage16Bits()

// Paglalagay ng object sa kinilalang eroplano
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 at ARKit: paghahambing

Bagaman ARCore at ARKit ay nilulutas ang parehong mga gawain — pagsubaybay sa posisyon, pagkilala sa eroplano at pagtatasa ng ilaw — ang kanilang mga approach at ecosystem ay magkaiba. Ang ARCore ay nagbibigay-priyoridad sa cross-platform at compatibility, habang ang ARKit ay gumagamit ng malalim na integrasyon sa Apple hardware.

Mga pangunahing pagkakaiba: gumagana ang ARCore sa Android at iOS sa pamamagitan ng ARCore SDK, ARKit — sa iOS lamang. Gumagamit ang ARCore ng Cloud Anchors para sa pag-sync sa pamamagitan ng Firebase, ARKit — ARWorldMap para sa direktang pagpapalitan sa pagitan ng mga device. Ang ARCore na may Depth API ay sumusuporta sa ToF sensors, ARKit na may LiDAR — laser scanning na may accuracy na hanggang 3 cm.

Ayon sa mga paghahambing na pagsusulit ng Google 2024, ang tracking accuracy ng ARCore sa mga device na may gyroscope at ToF sensor ay maihahambing sa ARKit sa iPhone na may LiDAR — ang error ay hindi lalampas sa 2 cm sa layo na 2 metro. Sa mga device na walang ToF, ang ARCore ay nahuhuli sa ARKit sa bilis ng pagsisimula: 3 segundo kumpara sa 0.5 segundo.

Ang pagpili sa pagitan ng ARCore at ARKit ay depende sa target na audience: kung ang app ay para sa iOS lamang — ang ARKit ay nagbibigay ng mas mahusay na performance at access sa eksklusibong LiDAR features. Kung kinakailangan ang suporta sa parehong platform — ang ARCore na may ARCore iOS SDK ay nagpapahintulot sa paggamit ng pare-parehong codebase na may minimal na pagkakaiba sa platform, kahit na may pagkawala ng ilang hardware capabilities ng bawat platform.

Pagsasama ng ARCore sa application

Ang pagsasama ng ARCore ay nagsisimula sa pagdaragdag ng dependency Google Play Services for AR sa build.gradle: com.google.ar:core. Dapat suriin ng app ang availability ng ARCore sa device sa pamamagitan ng ArCoreApk.checkAvailability() — kung hindi naka-install ang ARCore, imungkahi sa user na i-install ito mula sa Google Play Store.

Ang pangunahing proyekto ng ARCore ay may kasamang: paglikha ng Session at Config, pag-configure ng SurfaceView para sa pagpapakita ng camera, pagsisimula ng session sa pamamagitan ng session.resume() at pagproseso ng mga frame sa pamamagitan ng session.update(). Para sa rendering ng 3D objects gamit ang Sceneform SDK (library ng Google batay sa Filament) o Unity/Unreal para sa mga kumplikadong scene.

Inirerekomenda ng Google ang Sceneform para sa Kotlin apps — nagbibigay ito ng mga ready-made na component: ModelRenderable para sa pag-load ng 3D models (OBJ, glTF, FBX), ViewRenderable para sa pag-embed ng Android View sa AR scene at MotionEvent para sa paghawak ng mga touch. Ang Sceneform ay awtomatikong namamahala sa lifecycle ng AR session at paglabas ng mga resources.

Pamamahala ng mga pagkabigo sa pagsubaybay

Ang ARCore ay maaaring mawalan ng pagsubaybay sa hindi sapat na ilaw, pare-parehong mga surface o mabilis na paggalaw ng device. Ang status ng pagsubaybay ay available sa pamamagitan ng frame.getTrackingState() — mga value na TRACKING, PAUSED at STOPPED. Kapag lumipat sa PAUSED, inirerekomenda na i-pause ang rendering at ipakita sa user ang mga rekomendasyon: “Galawin nang mas mabagal ang device” o “Pumunta sa mas maliwanag na lugar”.

Para sa awtomatikong pagbawi pagkatapos ng pagkabigo, sinusuportahan ng ARCore ang relocalization batay sa naka-save na mapa ng mga feature points. Maaaring i-save ng developer ang mapa sa pamamagitan ng session.serialize() at ibalik ito sa pamamagitan ng session.deserialize() — ito ay kapaki-pakinabang para sa pangmatagalang AR experience kung saan bumalik ang user sa parehong pisikal na espasyo. Ang pagpapanumbalik ng mapa ay tumatagal ng 1–2 segundo, sa kondisyon na ang kapaligiran ay hindi nagbago nang malaki.

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