HoloLens Photo/Video Camera in Unreal

HoloLens ma aparat fotograficzny /wideo (PV) na visor, który może być używany zarówno do Mixed Reality Capture (MRC) i lokalizowania obiektów w przestrzeni Unreal world z współrzędnych pikseli w ramce aparatu.

Ważne

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

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 openXR dla Unreal 4.26 ma ograniczenie: aparat może pracować z DirectX11 RHI. To ograniczenie zostało naprawione w systemie Unreal 4.27.1 lub nowszym.

  • W Project Ustawienia HoloLens >włącz funkcję Kamery internetowej:

Screenshot of the HoloLens project settings with the Webcam property highlighted

  • Utwórz nowego aktora o nazwie "CamCapture" i dodaj płaszczyznę, aby renderować źródło kamery:

Screenshot of the an actor with an added plane

  • 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:

Blueprint of a material and texture sample

Renderowanie źródła danych kamery PV

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

Blueprint of the Toggle ARCapture function with the PV Camera turned on

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

Blueprint of the Create Dynamic Material Instance function

  • Pobierz teksturę z kanału informacyjnego aparatu i przypisz go do materiału dynamicznego, jeśli jest prawidłowy. Jeśli tekstura jest nieprawidłowa, uruchom czasomierz i spróbuj ponownie po upłynął limit czasu:

Blueprint of camera feed texture assigned to the dynamic material

  • Na koniec przeprowadź skalowanie płaszczyzny według współczynnika proporcji obrazu aparatu:

Blueprint of plane scaled relative to the camera images aspect ratio

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ć kamerę w przestrzeni światowej, aby uwzględnić przesunięcie.

GetPVCameraToWorldTransform dostaje transformację w świecie kamery PV i zostanie umieszczony na obiektywie kamery:

Blueprint of the Get PVCamera to World Transform function

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

Blueprint of the Get World Space Ray from Camera Point

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

Blueprint of Get PVCamera Intrinsics functions

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

Blueprint of the world space ray being used to find out what exists in the world space at a particular coordinate

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

Blueprint of a 2-meter ray cast from the camera lens to the camera-space position 1/4 from the top left of the frame

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 pliku 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ć do sceny siatkę statyczną:
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 aparatu projektu, zastosuj je do składnika siatki statycznej i uruchom aparat HoloLens.

W edytorze kliknij prawym przyciskiem myszy pozycję 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 ją na parametr tekstury w materiale CamTextureMaterial i przeskaluj statyczny składnik siatki według współczynnika 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));
    }
}

Następny punkt kontrolny programowania

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

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

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

Zobacz też