HoloLens foto-/videocamera in Unreal

De HoloLens heeft een Foto/Video camera (PV) in het vizier dat kan worden gebruikt voor zowel Mixed Reality Capture (MRC) als het zoeken naar objecten in unreal world space vanuit pixelcoördinaten in het cameraframe.

Belangrijk

De PV Camera wordt niet ondersteund met Holographic Remoting, maar het is mogelijk om een webcam te gebruiken die is aangesloten op uw pc om de HoloLens PV Camera-functionaliteit te simuleren.

Installatie van pv-camerafeed

Belangrijk

De PV-camera wordt geïmplementeerd in zowel Windows Mixed Reality als OpenXR-invoegtoepassingen. OpenXR moet echter wel de Microsoft OpenXR-invoegtoepassing installeren. Bovendien heeft OpenXR voor Unreal 4.26 een beperking: camera kan werken met DirectX11 RHI. Deze beperking is opgelost in Unreal 4.27.1 of hoger.

  • Schakel in Project Instellingen HoloLens >de webcamfunctie in:

Screenshot of the HoloLens project settings with the Webcam property highlighted

  • Maak een nieuwe actor met de naam CamCapture en voeg een vliegtuig toe om de camerafeed weer te geven:

Screenshot of the an actor with an added plane

  • Voeg de actor toe aan uw scène, maak een nieuw materiaal met de naam CamTextureMaterial met een bitmapobjectparameter en een patroonvoorbeeld. Verzend de rgb-gegevens van de textuur naar de uitvoer-emissive kleur:

Blueprint of a material and texture sample

De PV Camera Feed weergeven

  • Schakel in de blauwdruk CamCapture de PV-camera in:

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

  • Maak een dynamisch materiaalexemplaren van CamTextureMaterial en wijs dit materiaal toe aan het vliegtuig van de actor:

Blueprint of the Create Dynamic Material Instance function

  • Haal het patroon op uit de camerafeed en wijs het toe aan het dynamische materiaal als het geldig is. Als het patroon niet geldig is, start u een timer en probeert u het opnieuw na de time-out:

Blueprint of camera feed texture assigned to the dynamic material

  • Ten slotte schaalt u het vlak met de hoogte-breedteverhouding van de cameraafbeelding:

Blueprint of plane scaled relative to the camera images aspect ratio

Cameraposities zoeken in wereldruimte

De camera op de HoloLens 2 wordt verticaal verschoven van het hoofdtracering van het apparaat. Er zijn enkele functies om de camera in de wereld te vinden om rekening te houden met de offset.

GetPVCameraToWorldTransform krijgt de transformatie in de wereldruimte van de PV Camera en wordt op de cameralens geplaatst:

Blueprint of the Get PVCamera to World Transform function

GetWorldSpaceRayFromCameraPoint cast een ray van de cameralens naar de scène in Unreal world space om de inhoud van een pixel in het cameraframe te vinden:

Blueprint of the Get World Space Ray from Camera Point

GetPVCameraIntrinsics retourneert de intrinsieke waarden van de camera, die kunnen worden gebruikt bij het verwerken van computer vision op een cameraframe:

Blueprint of Get PVCamera Intrinsics functions

Als u wilt zoeken wat er in de wereldruimte op een bepaalde pixelcoördinaat bestaat, gebruikt u een lijntracering met de wereldruimtestraal:

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

Hier casten we een straal van 2 meter van de cameralens naar de cameraruimtepositie 1/4 vanaf de linkerbovenhoek van het frame. Gebruik vervolgens het trefferresultaat om iets weer te geven waarin het object zich in de wereldruimte bevindt:

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

Wanneer u ruimtelijke toewijzing gebruikt, komt deze hitpositie overeen met het oppervlak dat de camera ziet.

De PV Camera Feed weergeven in C++

  • Een nieuwe C++-actor maken met de naam CamCapture
  • Voeg in de build.cs van het project AugmentedReality toe aan de lijst PublicDependencyModuleNames:
PublicDependencyModuleNames.AddRange(
    new string[] {
        "Core",
        "CoreUObject",
        "Engine",
        "InputCore",
        "AugmentedReality"
});
  • Neem in CamCapture.h ARBlueprintLibrary.h op
#include "ARBlueprintLibrary.h"
  • U moet ook lokale variabelen voor de mesh en het materiaal toevoegen:
private:
    UStaticMesh* StaticMesh;
    UStaticMeshComponent* StaticMeshComponent;
    UMaterialInstanceDynamic* DynamicMaterial;
    bool IsTextureParamSet = false;
  • Werk in CamCapture.cpp de constructor bij om een statisch mesh toe te voegen aan de scène:
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);
}

Maak in BeginPlay een dynamisch materiaalexemplaren op basis van het cameramateriaal van het project, pas dit toe op het statische mesh-onderdeel en start de HoloLens camera.

Klik in de editor met de rechtermuisknop op camTextureMaterial in de inhoudsbrowser en selecteer 'Verwijzing kopiëren' om de tekenreeks voor CameraMatPath op te halen.

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

Stel in Tick het patroon van de camera in op de textuurparameter in het Materiaal CamTextureMaterial en schaal het statische mesh-onderdeel op de hoogte-breedteverhouding van het cameraframe:

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

Volgend controlepunt voor ontwikkeling

Als u het Unreal-ontwikkeltraject volgt dat we hebben opgesteld, bevindt u zich midden in het verkennen van de Mixed Reality platformmogelijkheden en API's. Hier kunt u doorgaan naar het volgende onderwerp:

Of ga rechtstreeks naar de implementatie van uw app op een apparaat of emulator:

U kunt altijd op elk gewenst moment teruggaan naar de unreal development checkpoints .

Zie ook