Udostępnij za pośrednictwem

Symulacja percepcji (wersja zapoznawcza)

Kliknij poniższy link, aby pobrać autonomiczny pakiet symulacji percepcji:

Symulacja percepcji (wersja zapoznawcza)

Ta autonomiczna wersja pakietu symulacji percepcji umożliwia częstsze aktualizacje niezależnie od wersji systemu operacyjnego i udostępnia nowe funkcje, w tym:

  • Nagrywanie i odtwarzanie: Możliwość rejestrowania akcji wykonywanych za pomocą symulacji percepcji na potrzeby odtwarzania w zautomatyzowany sposób z minimalnym kodem.

  • Walidatory: Podczas odtwarzania nagrań symulacja percepcji może wrócić do kodu testowego, gdzie można zweryfikować stan przy użyciu metadanych osadzonych w nagraniu.

  • Przesyłanie strumieniowe wideo: Interfejs użytkownika kontrola symulacji percepcji może wyświetlać widok na żywo urządzenia lub emulatora HoloLens 2 i zezwalać na bezpośrednią kontrolę przy użyciu klawiatury, myszy lub gamepadu, który jest podobny do emulatora HoloLens 2. Interfejs API klienta wideo jest również udostępniany w celu umożliwienia automatycznego testowania przechwytywania zrzutów ekranu.

  • Pełny natywny interfejs API: Oprócz dalszego udostępniania interfejsu API klienta kodu zarządzanego ta wersja zawiera nagłówki i biblioteki dla rozszerzonej symulacji percepcji lub pisania testów w języku C++.

  • Nowy klient REST: Podczas nawiązywania połączenia z urządzeniem zdalnym nowy natywny klient REST zapewnia zwiększoną niezawodność i umożliwia dostęp zarówno z natywnego, jak i zarządzanego kodu.

Wymagania systemowe

  • 60 MB miejsca na dysku

  • Windows 10 w wersji 2004 lub nowszej

Uwaga

Ta wersja symulacji percepcji instaluje i uruchamia równolegle wersję zawartą w systemach operacyjnych Windows 10 i 11. Skrót do kontrolki symulacji percepcji w menu Start zostanie uruchomiony i użyje tej wersji zapoznawczej, która jest przechowywana w \Program Files\Microsoft Perception Simulationprogramie . Jeśli uruchomisz narzędzia deweloperskie z poziomu portalu Mixed Reality, emulator HoloLens 2 lub z \Windows\System32\PerceptionSimulationpoziomu programu , uruchomisz starszą wersję. Aby użyć tej wersji zapoznawczej, pamiętaj, aby skompilować dowolny kod testowy przy użyciu zestawów referencyjnych lub nagłówków i bibliotek w obszarze \Program Files\Microsoft Perception Simulation.

Uwaga

Ta wersja jest zgodna z HoloLens 2 bez instalowania niczego nowego na zestawie słuchawkowym HoloLens 2. Przyszła aktualizacja HoloLens 2 włączy funkcję Usługi Scene Understanding w tej wersji zapoznawczej.

Instalacja

Instalator wersji zapoznawczej zainstaluje następujące składniki:

  • Aplikacja Kontrola symulacji percepcji: Ta aplikacja jest interfejsem użytkownika umożliwiającym ręczne sterowanie symulacją i tworzeniem nagrań.

  • Sterowniki symulacji percepcji: Obejmuje to sterownik zestawu słuchawkowego symulacji percepcji i sterownik kontrolera DoF Symulacja percepcji 6.00. Oba sterowniki są używane do Windows Mixed Reality.

  • Nagrania mapowania przestrzennego do użycia z HoloLens 2: są to te same nagrania, które są dostarczane z emulatorem HoloLens 2.

  • Przechwytywanie pokoju w funkcji Scena Understanding: Zostaną one włączone w przyszłej aktualizacji HoloLens 2.

  • Natywny zestaw SDK symulacji percepcji: Obejmuje to nagłówki i biblioteki języka C++, które umożliwiają pisanie narzędzi, aplikacji i automatyzacji testów, które programowo napędzają symulację percepcji z kodu natywnego.

  • Zarządzany zestaw SDK symulacji percepcji: Obejmuje to zarządzane zestawy referencyjne, które umożliwiają pisanie narzędzi, aplikacji i automatyzacji testowania, które programowo napędzają symulację percepcji z poziomu kodu zarządzanego.

Sterowanie ręczne

Aby kontrolować Windows Mixed Reality lub HoloLens 2 za pomocą klawiatury, myszy lub gamepada:

  1. Uruchom aplikację Kontrola symulacji percepcji .

  2. Wybierz produkt docelowy z listy rozwijanej w górnej części okna. W tej wersji użyj HoloLens 2 (starsza wersja) dla istniejących urządzeń HoloLens 2.

  3. W przypadku urządzenia zdalnego, takiego jak HoloLens, wprowadź adres IP urządzenia HoloLens lub emulatora.

    Upewnij się, że na urządzeniu docelowym jest włączony portal urządzeń .  Ta opcja jest domyślnie włączona w emulatorze HoloLens 2, ale musi być włączona ręcznie na fizycznym urządzeniu HoloLens lub na komputerze docelowym podczas korzystania z Windows Mixed Reality (zdalnego).

  4. Przełącz przełącznik zestawu słuchawkowego na włączony.

Tworzenie nagrania

Możesz utworzyć nagranie akcji ręcznej symulacji percepcji przy użyciu aplikacji Kontrola symulacji percepcji , a następnie odtworzyć nagranie ręcznie lub w zautomatyzowanym teście:

  1. Połącz się z urządzeniem docelowym.

  2. Przewiń w dół okna do momentu wyświetlenia sekcji Nagrania .

  3. Naciśnij przycisk Nagraj .

  4. Wybierz folder i nadaj mu nazwę pliku.

  5. Ręczne wykonywanie akcji w środowisku użytkownika przy użyciu kontrolki symulacji percepcji — rozglądanie się, interakcja itp.

    Podczas nagrywania możesz opcjonalnie wstawić krok weryfikacji do nagrania: wybierz przycisk Dodaj walidację , a następnie wypełnij wyświetlony wyskakujący interfejs użytkownika.

  6. Wybierz przycisk Zatrzymaj.  Nowe nagranie zostanie zapisane na dysku i załadowane automatycznie.  Naciśnij pozycję Odtwórz , aby odtworzyć akcje.

Tworzenie automatyzacji testów

Aby utworzyć automatyzację testów przy użyciu kodu zarządzanego:

  1. Utwórz nowy projekt kodu zarządzanego .NET Framework 4.7 w programie Visual Studio.

  2. Dodaj odwołania do PerceptionSimulation.Interop, PerceptionSimulationManager.Interop i SimulationStream.Interop.  Znajdziesz je w folderze zarządzanego zestawu SDK (%ProgramFiles%\Microsoft Perception Simulation\Sdk\References).

  3. Dodaj istniejący link elementu w projekcie kodu zarządzanego na PerceptionSimulationManager.dll wartość i ustaw go na wartość Kopiuj, jeśli jest nowsza.

  4. Dodaj using Microsoft.PerceptionSimulationelement .

Oto podstawowy przykładowy kod języka C#, który łączy się z zdalnym urządzeniem HoloLens, wykonuje gest Home (System), a następnie odtwarza nagranie:

using Microsoft.PerceptionSimulation; 
using System; 
 
namespace SimulationManagedTestApp 
{ 
    internal class Program 
    { 
        static void Main(string[] args) 
        { 
            string server = "http://192.168.0.1"; 
            ISimulationRestClient client = PerceptionSimulationManager.CreatePerceptionSimulationRestClient(server, null, null, StreamDataTypes.All, null); 
            client.Connect(); 
 
            ISimulationStreamSink sink = ((ISimulationStreamSinkFactory)client).CreateSimulationStreamSink(); 
            IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink); 
 
            manager.Human.LeftHand.Activated = true; 
            manager.Human.LeftHand.PerformGesture(SimulatedGesture.Home); 
 
            ISimulationRecording recording = PerceptionSimulationManager.LoadPerceptionSimulationRecording("C:\\Tools\\Recordings\\test.xef", ((ISimulationStreamSinkFactory)client), null); 
            recording.Play(); 
            // Instead of just sleeping here, you probably want to register an ISimulationRecordingCallback object to get state changes of the recording, and perhaps a callback to 
            // get validation request callbacks by implementing ISimulationRecordingCallback2 and providing that object to the LoadPerceptionSimulationRecording call. 
            System.Threading.Thread.Sleep(2500); 
 
            client.Disconnect(); 
 
            Console.ReadLine(); 
        } 
    } 
}

Uwaga

Jest to podobne do istniejącego przykładowego kodu, ale używa nowego ISimulationRestClient w wersji 3.  Ten klient implementuje ISimulationStreamSinkFactory i dlatego nadaje się do pobierania ujścia dla metod, które ich wymagają.

W następnym przykładzie jest to samo, co poprzedni, ale łączy się z Windows Mixed Reality na komputerze lokalnym:

using Microsoft.PerceptionSimulation; 
using System; 
 
namespace SimulationManagedTestApp 
{ 
    internal class Program 
    { 
        static void Main(string[] args) 
        { 
            string platformId = "B1DE8CAA-898F-474F-811A-F041FE3FD40D"; 
            string headsetId = PerceptionSimulationManager.InstallSimulatedHeadset(platformId, string.Empty); 
            ISimulationStreamSink sink = PerceptionSimulationManager.CreateControlStreamForDevice(headsetId); 
 
            IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink); 
 
            manager.Human.LeftHand.Activated = true; 
            manager.Human.LeftHand.PerformGesture(SimulatedGesture.Home); 
 
            // Instead of just sleeping here, you probably want to register an ISimulationRecordingCallback object to get state changes of the recording, and perhaps a callback to 
            // get validation request callbacks by implementing ISimulationRecordingCallback2 and providing that object to the LoadPerceptionSimulationRecording call. 
            System.Threading.Thread.Sleep(2500); 
 
            client.Disconnect(); 
 
            Console.ReadLine(); 
        } 
    } 
}

Identyfikatory platformy są przechowywane w rejestrze w obszarze HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Perception Simulation\Platforms.  Nazwy kluczy nie są używane, ale wartość identyfikatora wewnątrz to.  Na przykład identyfikator platformy dla Windows Mixed Reality to HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Perception Simulation\Platforms\WMR  (ID = "B1DE8CAA-898F-474F-811A-F041FE3FD40D").  Platformy można wyliczyć w kodzie przy użyciu funkcji , która PerceptionSimulationManager.GetAvailablePlatforms() zwraca tablicę SimulationPlatform struktur.  Każdy z nich SimulationPlatform zawiera różne szczegóły dotyczące platformy, w tym .PlatformId  W przypadku kodu PerceptionSimulationSettings::GetAvailablePlatforms() natywnego można użyć.  Natywna wersja interfejsu API zwraca liczbę i opcjonalnie wypełnia tablicę podaną przez obiekt wywołujący. Interfejs API można wywołać raz, aby pobrać liczbę, a następnie wywołać ją ponownie, aby tablica została wypełniona.

Możesz przeglądać bibliotekę, PerceptionSimulationManager.Interop aby wyświetlić dostępne klasy i metody.  Obejmuje on:

  • IPerceptionSimulationManager2, co umożliwia dodawanie ujścia w celu odbierania danych symulacji, ładowania danych usługi Scene Understanding, wysyłania danych dźwiękowych i programowego wstrzykiwania żądań weryfikacji. 

    Uwaga

    Niektóre funkcje nie są obecnie obsługiwane na urządzeniu HoloLens i Windows Mixed Reality.

  • ISimulatedSixDofController3, co umożliwia ustawienie położenia przycisków analogowych na kontrolerach ruchu.

  • ISimulationAudioVideoClient, który zawiera metody zapisywania tekstur na dysku. 

    Uwaga

    Aby przesyłanie strumieniowe wideo działało na urządzeniu HoloLens, musisz używać urządzenia fizycznego lub musi być włączone sprzętowe przyspieszanie grafiki w emulatorze HoloLens 2.  Emulator próbuje domyślnie włączyć sprzętowe przyspieszanie grafiki.

  • ISimulationRecordingCallback2, który test lub aplikacja może zaimplementować w celu obsługi żądań weryfikacji podczas odtwarzania nagrań.

W przypadku natywnego kodu C++:

  1. Dołącz poprawne nagłówki — PerceptionSimulationSettings.h i PerceptionSimulationManager.h

  2. Połącz odpowiednie biblioteki — PerceptionSimulationSettings.lib i PerceptionSimulationManager.lib co najmniej.  Jeśli korzystasz z funkcji Moduły sprawdzania poprawności, będziesz również potrzebować biblioteki PerceptionSimulationValidators.lib.  Jeśli korzystasz z funkcji audio/wideo, potrzebujesz opcji PerceptionSimulationOutput.lib

  3. Utwórz element PerceptionSimulationRestClient dla urządzenia HoloLens lub komputera Windows Mixed Reality zdalnego lub wywołaj urządzenie InstallSimulatedHeadset lokalne.  Funkcja InstallSimulatedHeadset zwróci identyfikator zestawu słuchawkowego, którego można użyć podczas tworzenia strumienia sterowania, aby komunikować się z urządzeniem.

  4. Utwórz strumień sterowania dla urządzenia.

  5. Utwórz wystąpienie menedżera symulacji percepcji.

Podstawowy przykładowy kod inicjowania symulacji:

// Simulation headers 
#include <perceptionsimulation.h> 
#include <perceptionsimulationmanager.h> 
#include <PerceptionSimulationSettings.h> 
 
// These would most likely be placed in a header and exist within a class scope 
winrt::com_ptr<IPerceptionSimulation2> m_spSimulation; 
winrt::com_ptr<IPerceptionSimulationManager> m_spSimulationManager; 
winrt::com_ptr<ISimulationStreamSink> m_spStreamSink; 
// The following are not needed if you intend to play back .xef files 
winrt::com_ptr<ISimulatedHuman> m_spHuman; 
winrt::com_ptr<ISimulatedHead2> m_spHead; 
winrt::com_ptr<ISimulatedHand3> m_spLeftHand; 
winrt::com_ptr<ISimulatedHand3> m_spRightHand; 
winrt::com_ptr<ISimulatedEyes> m_spEyes; 
 
std::string platformId = L"B1DE8CAA-898F-474F-811A-F041FE3FD40D"; // Windows Mixed Reality 
 
// This would most likely be in a setup/initialization function.  This can be done from any thread. 
winrt::com_ptr<IPerceptionSimulation> spSimulation; 
 
WCHAR deviceId[MAX_PATH] = { 0 }; 
winrt::check_hresult(PerceptionSimulationSettings::InstallSimulatedHeadset(platformId, nullptr, MAX_PATH, deviceId, m_spHeadset.put())); 
 
winrt::check_hresult(CoCreateInstance(__uuidof(PerceptionSimulation), nullptr, CLSCTX_LOCAL_SERVER, IID_PPV_ARGS(spSimulation.put()))); 
 
m_spSimulation = spSimulation.as<IPerceptionSimulation2>(); 
 
// Create a control stream for the device 
wil::unique_bstr path(devicePath); 
winrt::check_hresult(m_spSimulation->CreateControlStreamForDevice(deviceId, STREAM_PRIORITY_LOW, m_spStreamSink.put())); 
 
// Create the main Perception Simulation Manager object from which we'll get control of the simulated human and devices like controllers 

winrt::check_hresult(CreatePerceptionSimulationManager(m_spStreamSink.get(), m_spSimulationManager.put())); 
 
// If you intend to play .xef files instead of 'script' a test in code, stop here. 
 
winrt::check_hresult(m_spSimulationManager->get_Human(m_spHuman.put())); 
 
winrt::com_ptr<ISimulatedHead> spHead; 
winrt::check_hresult(m_spHuman->get_Head(spHead.put())); 
spHead.as(m_spHead); 
 
winrt::check_hresult(m_spHead->get_Eyes(m_spEyes.put())); 
 
winrt::com_ptr<ISimulatedHand> spHand; 
winrt::check_hresult(m_spHuman->get_RightHand(spHand.put())); 
spHand.as(m_spRightHand); 
 
// This code would most likely be part of a single test case 
 
// Activate the right hand 
m_spRightHand->put_Activated(TRUE); 
 
// Perform the system gesture. 
spHand->PerformGesture(SIMULATED_GESTURE::SIMULATED_GESTURE_HOME); 
 
// In your cleanup/shutdown path, you should remove the simulated headset (or ideally remove it only if it wasn't already present at the start of the test) 
// so you leave the machine in the same state that you found it. 
PerceptionSimulationSettings::RemoveSimulatedHeadset(deviceId);