HoloLens Zdjęcie/Kamera wideo w Unreal

Urządzenie HoloLens ma kamerę foto/wideo (PV) na wizjerze, która może być używana zarówno do Mixed Reality Capture (MRC) i lokalizowania obiektów w przestrzeni świata Unreal world ze współrzędnych pikseli w ramce aparatu.

Ważne

Kamera PV nie jest obsługiwana przy użyciu komunikacji wirtualnej Holographic Remoting, ale można użyć kamery internetowej dołączonej do komputera w celu symulowania funkcji kamery PV HoloLens.

4.26

Instalacja kanału informacyjnego kamery PV

Ważne

Kamera PV jest implementowana zarówno w wtyczkach Windows Mixed Reality, jak i OpenXR. Jednak rozszerzenie OpenXR wymaga zainstalowania wtyczki Microsoft OpenXR . Ponadto rozszerzenie OpenXR for Unreal 4.26 ma ograniczenie: aparat może pracować z directX11 RHI. To ograniczenie zostało naprawione w wersji Unreal 4.27.1 lub nowszej.

• W obszarze Ustawienia > projektu HoloLens włącz funkcję kamery internetowej :

• Utwórz nowego aktora o nazwie "CamCapture" i dodaj płaszczyznę w celu renderowania kanału informacyjnego kamery:

• Dodaj aktora do sceny, utwórz nowy materiał o nazwie CamTextureMaterial z parametrem obiektu tekstury i próbką tekstury. Wyślij dane rgb tekstury do koloru wyjściowego emisive:

Renderowanie kanału informacyjnego kamery PV

• W strategii CamCapture włącz kamerę PV:

• Utwórz dynamiczne wystąpienie materiału z camTextureMaterial i przypisz ten materiał do płaszczyzny aktora:

• Pobierz teksturę ze źródła kamery i przypisz ją do materiału dynamicznego, jeśli jest prawidłowa. Jeśli tekstura jest nieprawidłowa, uruchom czasomierz i spróbuj ponownie po przekroczeniu limitu czasu:

• Na koniec przeskaluj płaszczyznę według współczynnika proporcji obrazu aparatu:

Znajdowanie pozycji kamery w przestrzeni światowej

Aparat na HoloLens 2 jest przesunięty pionowo z śledzenia głowy urządzenia. Istnieje kilka funkcji, aby zlokalizować aparat w przestrzeni światowej, aby uwzględnić przesunięcie.

GetPVCameraToWorldTransform pobiera transformację w światowej przestrzeni kamery PV i zostanie umieszczony na obiektywie aparatu:

GetWorldSpaceRayFromCameraPoint rzuca promienie z obiektywu aparatu do sceny w przestrzeni świata Unreal, aby znaleźć zawartość piksela w ramce kamery:

Funkcja GetPVCameraIntrinsics zwraca wartości wewnętrzne aparatu, które mogą być używane podczas przetwarzania obrazów komputerowych na ramce aparatu:

Aby znaleźć to, co istnieje w przestrzeni światowej na określonej współrzędnej piksela, użyj śladu linii ze światowym promieniem kosmicznym:

Tutaj oddaliśmy 2-metrowy ray z obiektywu aparatu do pozycji przestrzeń kamery 1/4 z lewej górnej części ramy. Następnie użyj wyniku trafienia, aby renderować element, w którym obiekt istnieje w przestrzeni światowej:

W przypadku korzystania z mapowania przestrzennego ta pozycja trafienia będzie zgodna z powierzchnią, którą widzi aparat.

Renderowanie kanału informacyjnego kamery PV w języku C++

• Tworzenie nowego aktora języka C++ o nazwie CamCapture
• W pliku build.cs projektu dodaj element "AugmentedReality" do listy PublicDependencyModuleNames:

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

• W camCapture.h, dołącz ARBlueprintLibrary.h

#include "ARBlueprintLibrary.h"

• Należy również dodać zmienne lokalne dla siatki i materiału:

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

• W pliku CamCapture.cpp zaktualizuj konstruktor, aby dodać siatkę statyczną do sceny:

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

W elemencie BeginPlay utwórz dynamiczne wystąpienie materiału z materiału kamery projektu, zastosuj je do składnika siatki statycznej i uruchom aparat HoloLens.

W edytorze kliknij prawym przyciskiem myszy element CamTextureMaterial w przeglądarce zawartości i wybierz pozycję "Kopiuj odwołanie", aby pobrać ciąg 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);
}

W obszarze Tick pobierz teksturę z aparatu, ustaw go na parametr tekstury w materiale CamTextureMaterial i przeskaluj statyczny składnik siatki przez współczynnik proporcji ramki aparatu:

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

Renderowanie z kamery PV dla MRC

Uwaga

Wymaga to rozwiązania Unreal Engine 4.25 lub nowszego.

System i niestandardowe rejestratory MRC tworzą przechwytywanie rzeczywistości mieszanej przez połączenie kamery PV z hologramami rendernymi przez aplikację.

Domyślnie funkcja przechwytywania rzeczywistości mieszanej używa danych wyjściowych holograficznego oka. Jeśli aplikacja immersywna wybierze renderowanie z kamery PV, zostanie użyta zamiast tego. Renderowanie z kamery PV poprawia mapowanie między światem rzeczywistym a hologramami w filmie MRC.

Aby wyrazić zgodę na renderowanie z kamery PV:

1. Wywołaj metodę SetEnabledMixedRealityCamera i ResizeMixedRealityCamera
   • Użyj wartości Size X i Size Y , aby ustawić wymiary wideo.

Następnie Unreal będzie obsługiwać żądania od MRC do renderowania z perspektywy kamery PV.

Uwaga

Tylko wtedy, gdy Mixed Reality Przechwytywanie zostanie wyzwolone, aplikacja zostanie poproszona o renderowanie z perspektywy aparatu fotograficznego/wideo.

Korzystanie z kamery PV

Tekstura kamery internetowej można pobrać w grze w czasie wykonywania, ale musi być włączona w edytorze Edytuj > ustawienia projektu:

1. Przejdź do pozycji Platformy > Możliwości urządzenia HoloLens > i sprawdź kamerę internetową.
   • Użyj funkcji StartCameraCapture , aby użyć kamery internetowej w czasie wykonywania i funkcji StopCameraCapture , aby zatrzymać nagrywanie.

Renderowanie obrazu

Aby renderować obraz aparatu:

1. Utwórz dynamiczne wystąpienie materiału na podstawie materiału w projekcie o nazwie PVCamMat na poniższym zrzucie ekranu.
2. Ustaw wystąpienie materiału dynamicznego na zmienną dynamiczną odwołania do obiektu wystąpienia materiału .
3. Ustaw materiał obiektu w scenie, który renderuje źródło danych kamery do tego nowego dynamicznego wystąpienia materiału.
   • Uruchom czasomierz, który będzie używany do powiązania obrazu aparatu z materiałem.

4. Utwórz nową funkcję dla tego czasomierza, w tym przypadku MaterialTimer i wywołaj metodę GetARCameraImage , aby uzyskać teksturę z kamery internetowej.
5. Jeśli tekstura jest prawidłowa, ustaw parametr tekstury w cieniatorze na obraz. W przeciwnym razie ponownie uruchom czasomierz materiału.

5. Upewnij się, że materiał ma parametr pasujący do nazwy w elemecie SetTextureParameterValue powiązanym z wpisem koloru. Bez parametru nie można poprawnie wyświetlić obrazu aparatu.

Następny punkt kontrolny programowania

Jeśli obserwujesz określoną przez nas podróż deweloperów Unreal, jesteś w środku eksplorowania możliwości platformy Mixed Reality i interfejsów API. W tym miejscu możesz przejść do następnego tematu:

kody QR

Możesz też przejść bezpośrednio do wdrożenia aplikacji na urządzeniu lub emulatorze:

Wdrażanie na urządzeniu

Zawsze możesz wrócić do nierealnych punktów kontrolnych programowania w dowolnym momencie.

Zobacz też

• Aparat lokalizowalny
• Przechwytywanie rzeczywistości mieszanej dla deweloperów