HoloLens Foto/Videokamera i Unreal

HoloLens har en foto-/videokamera (PV) på visorn som kan användas både för Mixed Reality Capture (MRC) och för att hitta objekt i Unreal World Space från pixelkoordinater i kameraramen.

Viktigt

PV-kameran stöds inte med Holographic Remoting, men det är möjligt att använda en webbkamera som är ansluten till datorn för att simulera HoloLens PV-kamerafunktionen.

4.26

Installation av PV-kameraflöde

Viktigt

PV-kameran implementeras i både Windows Mixed Reality- och OpenXR-plugin-program. OpenXR måste dock ha Microsoft OpenXR-plugin-programmet installerat. OpenXR för Unreal 4.26 har också en begränsning: kameran kan arbeta med DirectX11 RHI. Den här begränsningen har åtgärdats i Unreal 4.27.1 eller senare.

• I Projektinställningar > HoloLens aktiverar du webbkamerafunktionen :

• Skapa en ny skådespelare med namnet "CamCapture" och lägg till ett plan för att återge kameraflödet:

• Lägg till aktören i din scen, skapa ett nytt material med namnet CamTextureMaterial med en texturobjektparameter och ett texturexempel. Skicka texturens rgb-data till utdatans tillåtande färg:

Återge PV-kameraflödet

• I CamCapture-skissen aktiverar du PV-kameran:

• Skapa en dynamisk materialinstans från CamTextureMaterial och tilldela det här materialet till aktörens plan:

• Hämta texturen från kameramatningen och tilldela den till det dynamiska materialet om det är giltigt. Om strukturen inte är giltig startar du en timer och försöker igen efter tidsgränsen:

• Skala slutligen planet efter kamerabildens bredd–höjd-förhållande:

Hitta kamerapositioner i världsrymden

Kameran på HoloLens 2 förskjuts vertikalt från enhetens huvudspårning. Det finns några funktioner för att hitta kameran i världsrymden för att kompensera för förskjutningen.

GetPVCameraToWorldTransform får omvandlingen i världsrymden för PV-kameran och kommer att placeras på kameralinsen:

GetWorldSpaceRayFromCameraPoint kastar en stråle från kameralinsen till scenen i Unreal world space för att hitta en pixels innehåll i kameraramen:

GetPVCameraIntrinsics returnerar kamerans inbyggda värden, som kan användas vid bearbetning av visuellt innehåll på en kameraram:

Om du vill hitta det som finns i världsrymden vid en viss pixelkoordinat använder du en linjespårning med världsrymdsstrålen:

Här kastar vi en 2-meters stråle från kameralinsen till kamerautrymmets position 1/4 från det övre vänstra hörnet av ramen. Använd sedan träffresultatet för att återge något där objektet finns i världsrymden:

När du använder rumslig mappning matchar träffpositionen den yta som kameran ser.

Återge PV-kameraflödet i C++

• Skapa en ny C++-aktör med namnet CamCapture
• I projektets build.cs lägger du till "AugmentedReality" i listan PublicDependencyModuleNames:

PublicDependencyModuleNames.AddRange(
    new string[] {
        "Core",
        "CoreUObject",
        "Engine",
        "InputCore",
        "AugmentedReality"
});

• I CamCapture.h inkluderar du ARBlueprintLibrary.h

#include "ARBlueprintLibrary.h"

• Du måste också lägga till lokala variabler för nät och material:

private:
    UStaticMesh* StaticMesh;
    UStaticMeshComponent* StaticMeshComponent;
    UMaterialInstanceDynamic* DynamicMaterial;
    bool IsTextureParamSet = false;

• I CamCapture.cpp uppdaterar du konstruktorn för att lägga till ett statiskt nät i scenen:

ACamCapture::ACamCapture()
{
    PrimaryActorTick.bCanEverTick = true;

    // Load a mesh from the engine to render the camera feed to.
    StaticMesh = LoadObject<UStaticMesh>(nullptr, TEXT("/Engine/EngineMeshes/Cube.Cube"), nullptr, LOAD_None, nullptr);

    // Create a static mesh component to render the static mesh
    StaticMeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("CameraPlane"));
    StaticMeshComponent->SetStaticMesh(StaticMesh);

    // Scale and add to the scene
    StaticMeshComponent->SetWorldScale3D(FVector(0.1f, 1, 1));
    this->SetRootComponent(StaticMeshComponent);
}

I BeginPlay skapar du en dynamisk materialinstans från projektets kameramaterial, tillämpar den på komponenten för statiskt nät och startar HoloLens-kameran.

I redigeraren högerklickar du på CamTextureMaterial i innehållswebbläsaren och väljer "Kopiera referens" för att hämta strängen för CameraMatPath.

void ACamCapture::BeginPlay()
{
    Super::BeginPlay();

    // Create a dynamic material instance from the game's camera material.
    // Right-click on a material in the project and select "Copy Reference" to get this string.
    FString CameraMatPath("Material'/Game/Materials/CamTextureMaterial.CamTextureMaterial'");
    UMaterial* BaseMaterial = (UMaterial*)StaticLoadObject(UMaterial::StaticClass(), nullptr, *CameraMatPath, nullptr, LOAD_None, nullptr);
    DynamicMaterial = UMaterialInstanceDynamic::Create(BaseMaterial, this);

    // Use the dynamic material instance when rendering the camera mesh.
    StaticMeshComponent->SetMaterial(0, DynamicMaterial);

    // Start the webcam.
    UARBlueprintLibrary::ToggleARCapture(true, EARCaptureType::Camera);
}

I Tick hämtar du strukturen från kameran, ställer in den på texturparametern i CamTextureMaterial-materialet och skalar den statiska nätkomponenten efter kameraramens proportioner:

void ACamCapture::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    // Dynamic material instance only needs to be set once.
    if(IsTextureParamSet)
    {
        return;
    }

    // Get the texture from the camera.
    UARTexture* ARTexture = UARBlueprintLibrary::GetARTexture(EARTextureType::CameraImage);
    if(ARTexture != nullptr)
    {
        // Set the shader's texture parameter (named "Param") to the camera image.
        DynamicMaterial->SetTextureParameterValue("Param", ARTexture);
        IsTextureParamSet = true;

        // Get the camera instrincs
        FARCameraIntrinsics Intrinsics;
        UARBlueprintLibrary::GetCameraIntrinsics(Intrinsics);

        // Scale the camera mesh by the aspect ratio.
        float R = (float)Intrinsics.ImageResolution.X / (float)Intrinsics.ImageResolution.Y;
        StaticMeshComponent->SetWorldScale3D(FVector(0.1f, R, 1));
    }
}

4.25

Rendera från PV-kameran för MRC

Anteckning

Detta kräver Unreal Engine 4.25 eller senare.

Systemet och anpassade MRC-inspelare skapar mixed reality-avbildningar genom att kombinera PV-kameran med hologram som återges av appen.

Som standard använder mixad verklighetsfångst höger ögas holografiska utdata. Om en avancerad app väljer att rendera från PV-kameran används den i stället. Rendering från PV-kameran förbättrar mappningen mellan den verkliga världen och hologram i MRC-videon.

Så här väljer du återgivning från PV-kameran:

1. Anropa SetEnabledMixedRealityCamera och ResizeMixedRealityCamera
   • Använd värdena Storlek X och Storlek Y för att ange videodimensionerna.

Unreal hanterar sedan begäranden från MRC som ska återges från PV-kamerans perspektiv.

Anteckning

Endast när Mixed Reality Capture utlöses uppmanas appen att rendera från foto-/videokamerans perspektiv.

Använda PV-kameran

Webbkamerastrukturen kan hämtas i spelet vid körning, men den måste aktiveras i redigerarens Redigera > projektinställningar:

1. Gå till Plattformar > HoloLens-funktioner > och kontrollera Webbkamera.
   • Använd funktionen StartCameraCapture för att använda webbkameran vid körning och funktionen StopCameraCapture för att stoppa inspelningen.

Återge en bild

Så här renderar du kamerabilden:

1. Skapa en dynamisk materialinstans baserat på ett material i projektet, som heter PVCamMat i skärmbilden nedan.
2. Ange dynamisk materialinstans till en referensvariabel för dynamiskt objekt för materialinstans .
3. Ange materialet för objektet i scenen som ska återge kameraflödet till den här nya dynamiska materialinstansen.
   • Starta en timer som ska användas för att binda kamerabilden till materialet.

4. Skapa en ny funktion för den här timern, i det här fallet MaterialTimer, och anropa GetARCameraImage för att hämta texturen från webbkameran.
5. Om strukturen är giltig anger du en texturparameter i skuggningen till bilden. Annars startar du materialtimern igen.

5. Kontrollera att materialet har en parameter som matchar namnet i SetTextureParameterValue som är bunden till en färgpost. Utan parametern kan kamerabilden inte visas korrekt.

Nästa kontrollpunkt för utveckling

Om du följer unreal-utvecklingsresan som vi har lagt fram är du mitt uppe i att utforska Mixed Reality plattformsfunktioner och API:er. Härifrån kan du fortsätta till nästa avsnitt:

QR-koder

Eller gå direkt till distributionen av appen på en enhet eller emulator:

Distribuera till enhet

Du kan alltid gå tillbaka till kontrollpunkterna för Unreal-utveckling när som helst.

Se även

• Locatable kamera
• Mixed Reality-avbildning för utvecklare