HoloLens foto-/videocamera in Unreal

Is deze pagina nuttig?

Nog meer feedback?

Feedback wordt verzonden naar Microsoft: als u de knop Verzenden kiest, wordt uw feedback gebruikt om Microsoft-producten en -services te verbeteren. Privacybeleid.

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.

4.26

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:

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

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

De PV Camera Feed weergeven

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

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

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

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

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:

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:

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

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

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:

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

4.25

Renderen vanaf de PV-camera voor MRC

Notitie

Hiervoor is Unreal Engine 4.25 of hoger vereist.

Het systeem en de aangepaste MRC-recorders maken mixed reality-opnamen door de PV-camera te combineren met hologrammen die door de app worden weergegeven.

Mixed Reality Capture maakt standaard gebruik van de holografische uitvoer van het rechteroog. Als een insluitende app ervoor kiest om te renderen vanuit de PV-camera, wordt dat in plaats daarvan gebruikt. Rendering van de PV Camera verbetert de toewijzing tussen de echte wereld en de hologrammen in de MRC-video.

Als u zich wilt aanmelden voor rendering vanaf de PV-camera:

1. SetEnabledMixedRealityCamera en ResizeMixedRealityCamera aanroepen
   • Gebruik de waarden Grootte X en Grootte Y om de videodimensies in te stellen.

Unreal verwerkt vervolgens aanvragen van MRC om te renderen vanuit het perspectief van de PV-camera.

Notitie

Alleen wanneer Mixed Reality Capture wordt geactiveerd, wordt de app gevraagd om vanuit het perspectief van de foto-/videocamera weer te geven.

De PV-camera gebruiken

Het bitmappatroon van de webcam kan tijdens runtime worden opgehaald in de game, maar moet zijn ingeschakeld in de editor bewerken > Project Instellingen:

1. Ga naar Platforms > HoloLens > mogelijkheden en controleer de webcam.
   • Gebruik de functie StartCameraCapture om de webcam tijdens runtime te gebruiken en de functie StopCameraCapture om de opname te stoppen.

Een afbeelding weergeven

De cameraafbeelding weergeven:

1. Maak een dynamisch materiaalexemplaren op basis van een materiaal in het project, met de naam PVCamMat in de onderstaande schermopname.
2. Stel het dynamische materiaalexemplaren in op een variabele voor dynamisch objectverwijzing voor materiaalexemplaren .
3. Stel het materiaal van het object in de scène in waarmee de camerafeed wordt weergegeven op dit nieuwe dynamische materiaalexemplaren.
   • Start een timer die wordt gebruikt om de camera-afbeelding aan het materiaal te binden.

4. Maak een nieuwe functie voor deze timer, in dit geval MaterialTimer, en roep GetARCameraImage aan om het patroon van de webcam op te halen.
5. Als het patroon geldig is, stelt u een patroonparameter in de arcering in op de afbeelding. Anders start u de materiaaltimer opnieuw.

5. Zorg ervoor dat het materiaal een parameter heeft die overeenkomt met de naam in SetTextureParameterValue die is gebonden aan een kleurvermelding. Zonder de parameter kan de camera-afbeelding niet goed worden weergegeven.

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:

QR-codes

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

Implementeren op apparaat

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

Zie ook

• Locatable camera
• Mixed reality-opname voor ontwikkelaars