Juster virtuelle hoveder med rigtige ansigter i enhed ved hjælp af MediaPipe

Udfordringer i Virtual Head Placement til AR-udvikling

At arbejde på et augmented reality-projekt (AR) kan være både spændende og udfordrende. Da jeg udviklede en Android-applikation med Unity, tilstræbte jeg at blande den digitale og den virkelige verden problemfrit ved at placere et virtuelt hoved over ansigter fra den virkelige verden. Denne funktion er stærkt afhængig af præcision for at skabe en fordybende oplevelse. 🕶️

For at opnå dette brugte jeg Googles MediaPipe til at opdage vartegn i ansigtet som øjne, næser og mund. Det virtuelle hoved blev derefter genereret og placeret baseret på disse nøglepunkter. Det var fascinerende at se, hvordan moderne værktøjer kunne transformere AR-muligheder, men rejsen var langt fra perfekt.

Problemet opstod, da det virtuelle hoved ikke var på linje med det faktiske ansigt som forventet. Uanset vinkel eller enhed, var placeringen altid en smule "off", hvilket førte til en unaturlig effekt. Det var, som om den virtuelle repræsentation var afbrudt fra virkeligheden. Dette udløste en række fejlfindingseksperimenter.

Fra at justere Unitys kameraindstillinger til at eksperimentere med MediaPipes algoritme, hvert forsøg medførte trinvise forbedringer, men ingen endelig løsning. Denne artikel dykker ned i kernen af ​​problemet, erfaringerne og potentielle løsninger for udviklere, der står over for lignende udfordringer. 🚀

Kommando	Eksempel på brug
mainCamera.usePhysicalProperties	Denne kommando muliggør brugen af ​​Unitys fysiske kameraegenskaber, hvilket giver mulighed for mere præcis kontrol over brændvidde og linseforvrængning for at justere virtuelle og virkelige objekter.
faceMesh.GetDetectedFaceTransform()	Henter transformationsdata (position og rotation) af et detekteret ansigt fra MediaPipes ansigtsmaske, der er afgørende for at placere virtuelle hoveder præcist over rigtige ansigter.
UnityObjectToClipPos	En shader-specifik funktion, der transformerer en toppunktsposition fra objektrum til clipspace, brugt i linseforvrængningskorrektion for at sikre justering.
tex2D	En shader-kommando, der bruges til at prøve en tekstur ved specificerede UV-koordinater, hvilket er afgørende for at anvende forvrængningskorrektion på kamerafeeds.
length(distUV)	Beregner den euklidiske afstand af UV-koordinater fra oprindelsen, som udnyttes til at anvende gradvise linseforvrængningsjusteringer.
adjuster.virtualHead	En scriptvariabel, der refererer til det virtuelle hoved GameObject, hvilket gør det muligt at opdatere dets position og rotation dynamisk baseret på ansigtssporingsdata.
[TestFixture]	En NUnit-attribut, der markerer en klasse som en testopstilling, hvilket signalerer, at den indeholder enhedstests. Dette er nyttigt til at verificere logik for virtuel hovedjustering.
Assert.AreEqual	En NUnit-metode, der bruges til at sammenligne forventede og faktiske værdier under enhedstest, hvilket sikrer, at den virtuelle hovedplacering matcher de ønskede resultater.
_DistortionStrength	En shader-egenskab, der justerer intensiteten af ​​linseforvrængning og finjusterer justeringen mellem den virkelige og virtuelle verden.
Quaternion.Euler	Opretter en rotation baseret på Euler-vinkler, der almindeligvis bruges til at justere objekter som det virtuelle hoved i Unitys 3D-rum.

Forbedring af AR-nøjagtighed med Unity og MediaPipe

Det første script, vi udforskede, fokuserer på at bruge Unitys fysiske kameraegenskaber. Ved at aktivere , justerer vi kameraets opførsel, så den matcher den virkelige verden bedre. Dette er især vigtigt, når du arbejder med AR, hvor selv små uoverensstemmelser i brændvidde eller synsfelt kan få virtuelle objekter til at se forkert ud. For eksempel kan indstilling af brændvidden til en præcis værdi som 35 mm hjælpe med at justere det virtuelle hoved med det detekterede ansigt. Denne justering svarer til finjustering af et teleskop for at bringe fjerne objekter i perfekt fokus, hvilket sikrer, at AR-oplevelsen føles naturlig og fordybende. 📸

En anden afgørende komponent i scriptet er at hente det detekterede ansigts position og rotation ved hjælp af . Denne funktion giver opdateringer i realtid fra MediaPipes face mesh, hvilket er essentielt for at synkronisere det virtuelle hoved med brugerens bevægelser. Forestil dig at spille et videospil, hvor din karakters hoved ikke bevæger sig synkront med dit eget; oplevelsen ville være rystende. Ved at sikre nøjagtig justering transformerer dette script AR fra en nyhed til et værktøj, der kan understøtte applikationer som virtuelle møder eller avanceret spil.

Det andet script dykker ned i shader-programmering, der specifikt adresserer linseforvrængning. Shaderen korrigerer forvrængninger i kameraets feed ved at bruge egenskaber som _DistortionStrength til at manipulere, hvordan UV-koordinater afbildes på teksturen. Dette er især nyttigt, når der er tale om vidvinkelobjektiver eller kameraer med unikke forvrængningsprofiler. For eksempel, hvis et virtuelt hoved ser større eller mindre ud end det faktiske ansigt afhængigt af vinklen, sikrer justering af forvrængningsindstillingerne bedre justering. Det er som at justere rammen af ​​et spejl for at eliminere en funhouse-effekt, hvilket gør refleksioner mere realistiske. 🎨

Til sidst validerer enhedstestene fra det tredje script løsningerne. Disse tests sammenligner den forventede position og rotation af det virtuelle hoved med de faktiske resultater, hvilket sikrer, at justeringer holder under forskellige forhold. Brug af NUnit's , kan udviklere simulere forskellige scenarier, som at flytte hovedet hurtigt eller vippe det i ekstreme vinkler for at bekræfte justeringen. For eksempel bemærkede jeg under udviklingen, at justering fungerede godt, når jeg vendte fremad, men drev, når hovedet vendte til siden. Disse enhedstests fremhævede problemet og vejledte yderligere forbedringer, hvilket forstærkede vigtigheden af ​​grundig test i at skabe robuste AR-applikationer. 🚀

// 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);
    }
}

Forfining af AR-placering gennem forbedrede kalibreringsteknikker

Et ofte overset aspekt af problemer med AR-justering er vigtigheden af ​​kamerakalibrering. I AR-projekter som at placere et virtuelt hoved over et rigtigt, er objektivets spiller en afgørende rolle. Disse parametre omfatter brændvidde, optisk center og forvrængningskoefficienter. Når disse værdier ikke er nøjagtige, kan det virtuelle hoved virke forkert justeret eller forvrænget. For at løse dette kan kalibreringsværktøjer bruges til at beregne disse parametre for det specifikke enhedskamera. For eksempel tilbyder software som OpenCV robuste kalibreringsværktøjer til at generere præcise kameramatricer og forvrængningsprofiler. 📐

En anden tilgang involverer at udnytte Unity's . Ved at anvende effekter som dybdeskarphed eller kromatisk aberrationskorrektion kan du udjævne uoverensstemmelser mellem det gengivede virtuelle hoved og det virkelige miljø. Efterbehandling tilføjer et lag polering, der bygger bro mellem virtuelle objekter og fysiske rum. For eksempel kan en subtil sløringseffekt reducere de hårde kanter, der gør fejljusteringer mærkbare. Dette er især nyttigt i fordybende applikationer, hvor brugerne er meget fokuserede på scenen.

Undervurder endelig ikke kraften ved dynamisk tilpasning under kørsel. Inkorporering af maskinlæringsmodeller i din AR-pipeline kan give systemet mulighed for at lære og justere placeringen over tid. For eksempel kunne en AI-model analysere brugerfeedback eller opdagede inkonsekvenser og finjustere justeringen dynamisk. Dette gør systemet mere robust og i stand til at håndtere variationer i belysning, enhedens ydeevne eller brugeradfærd. Disse forbedringer sikrer en problemfri AR-oplevelse, hvilket får den virtuelle og den virkelige verden til at føles virkelig integreret. 🚀

1. Hvorfor er mit virtuelle hoved forkert tilpasset det rigtige ansigt?
2. Problemet stammer ofte fra forkert kamerakalibrering. Brug af værktøjer som OpenCV til at beregne og kan i høj grad forbedre tilpasningen.
3. Hvilken rolle spiller brændvidden i AR-justering?
4. De definerer, hvordan kameraet projicerer 3D-punkter på et 2D-plan. Justering af det i Unitys fysiske kameraindstillinger kan øge nøjagtigheden.
5. Kan Unity håndtere linseforvrængningskorrektion?
6. Ja, Unity understøtter shaders til forvrængningskorrektion. Implementer en shader med egenskaber som for at tilpasse rettelser baseret på din linseprofil.
7. Hvordan kan jeg teste justeringen af ​​virtuelle objekter?
8. Brug af enhedstest i NUnit med kommandoer som giver dig mulighed for at validere placeringen og rotationen af ​​virtuelle objekter under forskellige forhold.
9. Er efterbehandling nødvendig for AR-projekter?
10. Selvom det ikke er obligatorisk, efterbehandlingseffekter som og kan forbedre den visuelle kvalitet og realisme af AR-scener.
11. Kan MediaPipe registrere andre genstande end ansigter?
12. Ja, MediaPipe tilbyder løsninger til hænder, positur og endda holistisk sporing, hvilket gør det alsidigt til forskellige AR-brugstilfælde.
13. Hvilken hardware fungerer bedst til Unity AR-applikationer?
14. Enheder med højtydende GPU'er og præcise kameraer er ideelle. Værktøjer som og øge kompatibiliteten yderligere.
15. Hvorfor er justeringen værre i visse vinkler?
16. Dette kan skyldes et misforhold i synsfeltet mellem kameraet og det virtuelle miljø. Justering af Unity-kameraerne ejendom kan hjælpe.
17. Hvordan forbedrer shaders AR-justering?
18. Shaders giver mulighed for realtidsjusteringer af gengivelsen, såsom at korrigere forvrængninger eller simulere linseeffekter, hvilket sikrer bedre synkronisering mellem virtuelle og virkelige objekter.
19. Kan AR-systemer selv justere sig over tid?
20. Ja, integration af maskinlæringsmodeller gør det muligt for systemer at tilpasse sig dynamisk, ved at lære af feedback for at forbedre justering og ydeevne over tid.

At opnå præcis justering mellem virtuelle og virkelige objekter er afgørende for fordybende AR-oplevelser. Gennem omhyggelig kalibrering og avancerede teknikker kan problemer som linseforvrængning og uoverensstemmende brændvidder afbødes, hvilket sikrer bedre nøjagtighed og brugertilfredshed.

Integration af Unitys værktøjer, MediaPipe-algoritmer og dynamiske justeringer giver robuste løsninger til AR-udviklere. Disse forbedringer muliggør en sømløs blanding af digitale og fysiske verdener, hvilket åbner op for nye muligheder for spil, virtuelle møder og mere. Med vedholdenhed og innovation bliver AR-tilpasningsudfordringer håndterbare. 🚀