Virtuális fejek igazítása valódi arcokhoz a Unityben a MediaPipe használatával

A virtuális fejelhelyezés kihívásai az AR-fejlesztéshez

A kiterjesztett valóság (AR) projekten való munka izgalmas és kihívást is jelenthet. Amikor Android-alkalmazást fejlesztettem a Unity-vel, arra törekedtem, hogy zökkenőmentesen vegyítsem a digitális és a valós világot úgy, hogy virtuális fejet helyeztem a valós arcok fölé. Ez a funkció nagymértékben támaszkodik a pontosságra, hogy magával ragadó élményt hozzon létre. 🕶️

Ennek eléréséhez a Google MediaPipe-ját használtam az arc tereptárgyainak, például a szemek, az orr és a száj észlelésére. A virtuális fejet ezután ezek alapján a kulcspontok alapján létrehozták és elhelyezték. Lenyűgöző volt látni, hogy a modern eszközök hogyan tudják átalakítani az AR lehetőségeket, de az utazás korántsem volt tökéletes.

A probléma akkor merült fel, amikor a virtuális fej nem a várt módon igazodott a tényleges archoz. Függetlenül a szögtől vagy az eszköztől, az elhelyezés mindig "kiesett", ami természetellenes hatást eredményezett. Mintha a virtuális ábrázolás elszakadt volna a valóságtól. Ez egy sor hibaelhárítási kísérletet indított el.

A Unity kamerabeállításainak módosításától a MediaPipe algoritmussal való kísérletezésig minden próbálkozás fokozatos javulást hozott, de végleges megoldást nem. Ez a cikk a probléma lényegét, a levont tanulságokat és a hasonló kihívásokkal szembesülő fejlesztők számára kínált lehetséges megoldásokat ismerteti. 🚀

Parancs	Használati példa
mainCamera.usePhysicalProperties	Ez a parancs lehetővé teszi a Unity fizikai kameratulajdonságainak használatát, lehetővé téve a gyújtótávolság és az objektív torzításának pontosabb szabályozását a virtuális és a valós objektumok összehangolásához.
faceMesh.GetDetectedFaceTransform()	Lekéri az észlelt arc átalakítási adatait (pozíció és elforgatás) a MediaPipe archálójából, ami kulcsfontosságú a virtuális fejek pontos elhelyezéséhez a valódi arcok fölé.
UnityObjectToClipPos	Árnyékoló-specifikus funkció, amely a csúcspozíciót objektumtérből kliptérré alakítja, és az objektív torzításkorrekciós shadereiben használják az igazítás biztosítására.
tex2D	Shader parancs, amely a textúra meghatározott UV-koordinátákon történő mintázására szolgál, és elengedhetetlen a torzításkorrekció alkalmazásához a kamera feedjein.
length(distUV)	Kiszámítja az UV-koordináták euklideszi távolságát az origótól, amelyet a lencse torzításának fokozatos korrekcióihoz használ fel.
adjuster.virtualHead	A GameObject virtuális fejére utaló szkriptváltozó, amely lehetővé teszi a pozíciójának és elforgatásának dinamikus frissítését az arckövetési adatok alapján.
[TestFixture]	Egy NUnit attribútum, amely egy osztályt teszt fixtureként jelöl meg, jelezve, hogy egységteszteket tartalmaz. Ez hasznos a virtuális fej-igazítási logika ellenőrzéséhez.
Assert.AreEqual	Egy NUnit módszer a várt és a tényleges értékek összehasonlítására az egységteszt során, biztosítva, hogy a virtuális fej elhelyezése megfeleljen a kívánt eredményeknek.
_DistortionStrength	Árnyékoló tulajdonság, amely beállítja az objektív torzításának intenzitását, finomhangolva a valós és a virtuális világ közötti igazodást.
Quaternion.Euler	Elforgatást hoz létre az Euler-szögek alapján, amelyeket általában olyan objektumok igazításához használnak, mint például a virtuális fej a Unity 3D-s terében.

Az AR pontosságának növelése a Unity és a MediaPipe segítségével

Az első általunk vizsgált szkript a Unity fizikai kameratulajdonságainak felhasználására összpontosít. Engedélyezésével , úgy állítjuk be a kamera viselkedését, hogy jobban illeszkedjen a való világ optikájához. Ez különösen akkor fontos, ha AR-vel dolgozik, ahol a gyújtótávolság vagy a látómező enyhe eltérései miatt a virtuális objektumok rosszul igazodhatnak. Például a gyújtótávolság pontos értékre, például 35 mm-re történő beállítása segíthet a virtuális fejnek az észlelt archoz igazításában. Ez a beállítás a teleszkóp finomhangolásához hasonlít, hogy a távoli tárgyakat tökéletes fókuszba állítsa, így az AR-élmény természetes és magával ragadó. 📸

A szkript másik kulcsfontosságú összetevője az észlelt arc helyzetének és elforgatásának lekérése . Ez a funkció valós idejű frissítéseket biztosít a MediaPipe archálójából, ami elengedhetetlen a virtuális fej és a felhasználó mozgásainak szinkronizálásához. Képzeljen el egy olyan videojátékot, ahol a karakter feje nem mozog szinkronban a sajátjával; az élmény megrázó lenne. A pontos igazítás biztosításával ez a szkript az AR-t újdonságból olyan eszközzé alakítja, amely támogatja az olyan alkalmazásokat, mint a virtuális találkozók vagy a fejlett játék.

A második szkript a shader programozással foglalkozik, kifejezetten az objektív torzításával foglalkozik. A shader kijavítja a torzulásokat a kamera feedjében, és olyan tulajdonságokat használ, mint a _DistortionStrength, hogy manipulálja az UV-koordináták leképezését a textúrára. Ez különösen akkor hasznos, ha nagy látószögű objektívekkel vagy egyedi torzítási profillal rendelkező fényképezőgépekkel dolgozik. Például, ha egy virtuális fej a szögtől függően nagyobbnak vagy kisebbnek tűnik, mint a tényleges arc, a torzítási beállítások módosítása jobb igazítást biztosít. Ez olyan, mintha egy tükör keretét állítaná be, hogy kiküszöbölje a funhouse hatást, és valósághűbbé tegye a tükröződést. 🎨

Végül a harmadik szkript egységtesztjei érvényesítik a megoldásokat. Ezek a tesztek összehasonlítják a virtuális fej várható helyzetét és forgását a tényleges eredményekkel, biztosítva, hogy a beállítások különböző körülmények között is megálljanak. NUnit használatával , a fejlesztők különböző forgatókönyveket szimulálhatnak, például a fej gyors mozgatását vagy szélsőséges szögben történő megdöntését az igazítás megerősítése érdekében. Például a fejlesztés során észrevettem, hogy az igazítás jól működött előre fordítva, de sodródott, amikor a fej oldalra fordult. Ezek az egységtesztek rávilágítottak a problémára, és további fejlesztésekhez vezettek, megerősítve az alapos tesztelés fontosságát a robusztus AR-alkalmazások létrehozásában. 🚀

// Import necessary Unity libraries
using UnityEngine;
using Mediapipe.Unity;

public class VirtualHeadAdjuster : MonoBehaviour
{
    public Camera mainCamera; // Assign Unity's physical camera
    public GameObject virtualHead; // Assign the virtual head prefab
    private MediapipeFaceMesh faceMesh; // MediaPipe's face mesh component

    void Start()
    {
        // Enable Unity's physical camera
        mainCamera.usePhysicalProperties = true;
        mainCamera.focalLength = 35f; // Set a standard focal length
    }

    void Update()
    {
        if (faceMesh != null && faceMesh.IsTracking)
        {
            // Update the virtual head's position and rotation
            Transform detectedHead = faceMesh.GetDetectedFaceTransform();
            virtualHead.transform.position = detectedHead.position;
            virtualHead.transform.rotation = detectedHead.rotation;
        }
    }
}

Shader "Custom/LensDistortionCorrection"
{
    Properties
    {
        _DistortionStrength ("Distortion Strength", Float) = 0.5
    }

    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            float _DistortionStrength;

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
            };

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                return o;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float2 distUV = i.uv - 0.5;
                distUV *= 1.0 + _DistortionStrength * length(distUV);
                distUV += 0.5;
                return tex2D(_MainTex, distUV);
            }
            ENDCG
        }
    }
}

using NUnit.Framework;
using UnityEngine;
using Mediapipe.Unity;

[TestFixture]
public class VirtualHeadAlignmentTests
{
    private VirtualHeadAdjuster adjuster;
    private GameObject testHead;

    [SetUp]
    public void Init()
    {
        GameObject cameraObject = new GameObject("MainCamera");
        adjuster = cameraObject.AddComponent<VirtualHeadAdjuster>();
        testHead = new GameObject("VirtualHead");
        adjuster.virtualHead = testHead;
    }

    [Test]
    public void TestVirtualHeadAlignment()
    {
        Vector3 expectedPosition = new Vector3(0, 1, 2);
        Quaternion expectedRotation = Quaternion.Euler(0, 45, 0);

        adjuster.virtualHead.transform.position = expectedPosition;
        adjuster.virtualHead.transform.rotation = expectedRotation;

        Assert.AreEqual(expectedPosition, testHead.transform.position);
        Assert.AreEqual(expectedRotation, testHead.transform.rotation);
    }
}

Az AR-elhelyezés finomítása továbbfejlesztett kalibrációs technikákkal

Az AR-igazítási problémák egyik gyakran figyelmen kívül hagyott aspektusa a kamera kalibrálásának fontossága. Az AR-projektekben, például egy virtuális fej elhelyezése egy valódi, az objektív fölé létfontosságú szerepet játszanak. Ezek a paraméterek magukban foglalják a gyújtótávolságot, az optikai középpontot és a torzítási együtthatókat. Ha ezek az értékek nem pontosak, a virtuális fej helytelenül vagy torznak tűnhet. Ennek megoldására kalibrációs eszközök használhatók ezen paraméterek kiszámítására az adott eszköz kamerájához. Például az OpenCV-hez hasonló szoftverek robusztus kalibrációs segédprogramokat kínálnak precíz kameramátrixok és torzítási profilok létrehozásához. 📐

Egy másik megközelítés magában foglalja a Unity kihasználását . Az olyan effektusok alkalmazásával, mint a mélységélesség vagy a kromatikus aberráció korrekciója, kisimíthatja a megjelenített virtuális fej és a valós környezet közötti eltéréseket. Az utófeldolgozás egy fényezési réteget ad hozzá, amely áthidalja a szakadékot a virtuális objektumok és a fizikai terek között. Például egy finom elmosódás csökkentheti az éles éleket, amelyek észrevehetővé teszik az elmozdulásokat. Ez különösen hasznos a magával ragadó alkalmazásokban, ahol a felhasználók nagy mértékben a jelenetre koncentrálnak.

Végül ne becsülje alá a dinamikus alkalmazkodás erejét a futás közben. A gépi tanulási modellek beépítése az AR-folyamatba lehetővé teszi a rendszer számára, hogy megtanulja és idővel módosítsa az elhelyezést. Például egy mesterséges intelligencia modell elemezheti a felhasználói visszajelzéseket vagy az észlelt következetlenségeket, és dinamikusan finomhangolhatja az igazítást. Ez robusztusabbá teszi a rendszert, és képes kezelni a világítás, az eszköz teljesítménye vagy a felhasználói viselkedés változásait. Ezek a fejlesztések zökkenőmentes AR-élményt biztosítanak, így a virtuális és a valós világ valóban integráltnak tűnik. 🚀

1. Miért nem igazodik a virtuális fejem a valódi arcomhoz?
2. A probléma gyakran a kamera nem megfelelő kalibrálásából adódik. Olyan eszközök használatával, mint az OpenCV a kiszámításához és nagyban javíthatja az igazítást.
3. Mi a gyújtótávolság szerepe az AR igazításban?
4. A meghatározza, hogy a kamera hogyan vetíti ki a 3D pontokat egy 2D síkra. A Unity fizikai kamerabeállításaiban történő módosítás növelheti a pontosságot.
5. A Unity képes kezelni az objektívtorzítás korrekcióját?
6. Igen, a Unity támogatja a shadereket a torzításkorrekcióhoz. Valósítson meg egy shadert olyan tulajdonságokkal, mint a korrekciók testreszabásához az objektív profilja alapján.
7. Hogyan tesztelhetem a virtuális objektumok igazítását?
8. Egységtesztek használata NUnitben olyan parancsokkal, mint pl lehetővé teszi a virtuális objektumok pozicionálásának és elforgatásának ellenőrzését különféle feltételek mellett.
9. Szükséges utófeldolgozás az AR-projektekhez?
10. Bár nem kötelező, az utófeldolgozási hatások, mint pl és javíthatja az AR-jelenetek vizuális minőségét és valósághűségét.
11. A MediaPipe képes felismerni az arcokon kívül más tárgyakat is?
12. Igen, a MediaPipe megoldásokat kínál a kezekre, pózokra, sőt holisztikus követésre is, így sokoldalúan használható különféle AR felhasználási esetekben.
13. Melyik hardver működik a legjobban a Unity AR alkalmazásokhoz?
14. Ideálisak a nagy teljesítményű GPU-val és precíz kamerákkal rendelkező eszközök. Olyan eszközök, mint és tovább javítja a kompatibilitást.
15. Miért rosszabb az igazítás bizonyos szögekben?
16. Ennek oka lehet a kamera és a virtuális környezet látómezőjének eltérése. A Unity kamera beállítása ingatlan segíthet.
17. Hogyan javítják a shaderek az AR-igazítást?
18. Az árnyékolók lehetővé teszik a renderelés valós idejű módosítását, például a torzítások korrigálását vagy az objektíveffektusok szimulálását, így biztosítva a jobb szinkronizálást a virtuális és a valós objektumok között.
19. Az AR-rendszerek idővel önbeállíthatják magukat?
20. Igen, a gépi tanulási modellek integrálása lehetővé teszi, hogy a rendszerek dinamikusan alkalmazkodjanak, tanuljanak a visszajelzésekből, hogy idővel javítsák az igazítást és a teljesítményt.

A virtuális és a valós objektumok pontos igazítása kulcsfontosságú a magával ragadó AR-élményekhez. A gondos kalibráció és a fejlett technikák révén az olyan problémák enyhíthetők, mint az objektív torzulása és a nem megfelelő gyújtótávolság, ami nagyobb pontosságot és a felhasználói elégedettséget biztosít.

A Unity eszközeinek, MediaPipe algoritmusainak és dinamikus beállításainak integrálása robusztus megoldásokat kínál az AR-fejlesztők számára. Ezek a fejlesztések lehetővé teszik a digitális és a fizikai világ zökkenőmentes ötvözetét, új lehetőségeket nyitva a játékhoz, a virtuális találkozókhoz és azon túl. A kitartás és az innováció révén az AR-igazítási kihívások kezelhetővé válnak. 🚀