Condividi tramite

Simulazione della percezione (anteprima)

Fare clic sul collegamento seguente per scaricare il pacchetto autonomo Perception Simulation:

Simulazione percezione (anteprima)

Questa versione autonoma del pacchetto di Perception Simulation consente aggiornamenti più frequenti indipendentemente dalle versioni del sistema operativo e offre nuove funzionalità, tra cui:

  • Registrazione e riproduzione: Possibilità di registrare le azioni eseguite con Perception Simulation per la riproduzione in modo automatizzato con codice minimo.

  • Validator: Durante la riproduzione delle registrazioni, Perception Simulation può richiamare nel codice di test, in cui è possibile convalidare lo stato usando i metadati incorporati nella registrazione.

  • Streaming video: L'interfaccia utente Perception Simulation Control può visualizzare una visualizzazione dinamica di HoloLens 2 dispositivo o emulatore e consentire il controllo diretto tramite tastiera, mouse o game pad, che è simile all'emulatore di HoloLens 2. Viene fornita anche un'API client video per consentire ai test automatizzati di acquisire screenshot.

  • API nativa completa: Oltre a continuare a fornire un'API client di codice gestito, questa versione include intestazioni e librerie per la simulazione della percezione estesa o la scrittura di test in C++.

  • Nuovo client REST: Quando ci si connette a un dispositivo remoto, il nuovo client REST nativo offre maggiore affidabilità e consente l'accesso sia da codice nativo che da codice gestito.

Requisiti di sistema

  • 60 MB di spazio su disco

  • Windows 10 versione 2004 o successiva

Nota

Questa versione di Perception Simulation installa ed esegue side-by-side con la versione contenuta nei sistemi operativi Windows 10 e 11. Il collegamento a Perception Simulation Control (Controllo simulazione percezione ) nel menu Start verrà avviato e userà questa versione di anteprima, archiviata in \Program Files\Microsoft Perception Simulation. Se si avviano gli strumenti di sviluppo dall'interno del portale di Realtà mista, l'emulatore di HoloLens 2 o da \Windows\System32\PerceptionSimulation, verrà eseguita la versione precedente. Per usare questa versione di anteprima, assicurarsi di compilare qualsiasi codice di test usando gli assembly di riferimento o le intestazioni e le librerie in \Program Files\Microsoft Perception Simulation.

Nota

Questa versione è compatibile con HoloLens 2 senza installare nulla di nuovo nel visore VR HoloLens 2. Un aggiornamento futuro a HoloLens 2 abiliterà la funzionalità Scene Understanding in questa versione di anteprima.

Installazione

Il programma di installazione dell'anteprima installerà i componenti seguenti:

  • L'app Perception Simulation Control: Questa app è l'interfaccia utente per controllare manualmente la simulazione e la creazione di registrazioni.

  • I driver di Simulazione percezione: Sono inclusi il driver Perception Simulation Headset e il driver Perception Simulation 6-DOF Controller. Entrambi i driver vengono usati per Windows Mixed Reality.

  • Registrazioni di mapping spaziale da usare con HoloLens 2: si tratta delle stesse registrazioni fornite con l'emulatore di HoloLens 2.

  • Acquisizioni della sala di comprensione della scena: Queste funzionalità verranno abilitate in un aggiornamento futuro HoloLens 2.

  • Perception Simulation Native SDK: Sono incluse le intestazioni e le librerie C++ che consentono di scrivere strumenti, app e automazione di test che determinano la simulazione della percezione a livello di codice dal codice nativo.

  • Perception Simulation Managed SDK: Sono inclusi assembly di riferimento gestiti che consentono di scrivere strumenti, app e automazione di test che determinano la simulazione della percezione a livello di codice dal codice gestito.

Controllo manuale

Per controllare Windows Mixed Reality o HoloLens 2 tramite tastiera, mouse o game pad:

  1. Avviare l'app Perception Simulation Control .

  2. Selezionare il prodotto di destinazione nell'elenco a discesa nella parte superiore della finestra. Per questa versione, usare HoloLens 2 (legacy) per i dispositivi HoloLens 2 esistenti.

  3. Per un dispositivo remoto, ad esempio HoloLens, immettere l'indirizzo IP del dispositivo o dell'emulatore HoloLens.

    Assicurarsi che Device Portal sia abilitato nel dispositivo di destinazione.  Questa opzione è abilitata per impostazione predefinita nell'emulatore di HoloLens 2, ma deve essere abilitata manualmente in un dispositivo HoloLens fisico o nel PC di destinazione quando si usa Windows Mixed Reality (remoto).This is enabled by default in the HoloLens 2 Emulator, but will be enabled manually on a physical HoloLens device, or on the target PC when using Windows Mixed Reality (Remote).

  4. Attivare o disattivare l'interruttore Visore VR.

Creazione di una registrazione

È possibile creare una registrazione delle azioni di simulazione della percezione manuale usando l'app Perception Simulation Control e quindi riprodurre la registrazione manualmente o in un test automatizzato:

  1. Connettersi al dispositivo di destinazione.

  2. Scorrere verso il basso la finestra fino a visualizzare la sezione Registrazioni .

  3. Premere il pulsante Registra .

  4. Selezionare una cartella e assegnare un nome file alla registrazione.

  5. Eseguire manualmente le azioni nell'esperienza utente usando il controllo simulazione percezione : guardarsi intorno, interagire e così via.

    Durante la registrazione, è possibile inserire facoltativamente un passaggio di convalida nella registrazione: selezionare il pulsante Aggiungi convalida e quindi compilare l'interfaccia utente popup visualizzata.

  6. Selezionare il pulsante Arresta .  La nuova registrazione verrà salvata su disco e caricata automaticamente.  Premere Play per riprodurre le azioni.

Creazione dell'automazione dei test

Per creare l'automazione dei test usando il codice gestito:

  1. Creare un nuovo progetto di codice gestito di .NET Framework 4.7 in Visual Studio.

  2. Aggiungere riferimenti a PerceptionSimulation.Interope PerceptionSimulationManager.InteropSimulationStream.Interop.  Questi sono disponibili nella cartella SDK gestita (%ProgramFiles%\Microsoft Perception Simulation\Sdk\References).

  3. Aggiungere un collegamento di elemento esistente nel progetto di codice gestito a PerceptionSimulationManager.dll e impostarlo su Copia se più recente.

  4. Aggiungere using Microsoft.PerceptionSimulation.

Ecco il codice C# di esempio di base che si connette a un dispositivo HoloLens remoto, esegue un movimento Home (System) e quindi riproduce una registrazione:

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

Nota

È simile al codice di esempio esistente, ma usa il nuovo ISimulationRestClient in v3.  Questo client implementa ISimulationStreamSinkFactory e quindi è adatto per ottenere sink per i metodi che li richiedono.

L'esempio seguente esegue la stessa operazione di quella precedente, ma si connette a Windows Mixed Reality nel computer locale:

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

Gli ID piattaforma vengono archiviati nel Registro di sistema in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Perception Simulation\Platforms.  I nomi delle chiavi non vengono usati, ma il valore ID all'interno è.  Ad esempio, l'ID piattaforma per Windows Mixed Reality si trova in HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Perception Simulation\Platforms\WMR  (ID = "B1DE8CAA-898F-474F-811A-F041FE3FD40D").  È possibile enumerare le piattaforme nel codice usando PerceptionSimulationManager.GetAvailablePlatforms() la quale restituisce una matrice di SimulationPlatform struct.  Ognuno SimulationPlatform fornisce vari dettagli sulla piattaforma, tra cui .PlatformId  Per il codice nativo, PerceptionSimulationSettings::GetAvailablePlatforms() è possibile usare .  La versione nativa dell'API restituisce un conteggio e facoltativamente compila la matrice fornita dal chiamante. È possibile chiamare l'API una sola volta per ottenere il conteggio, quindi chiamarlo di nuovo per fare in modo che la matrice venga popolata.

È possibile esplorare la PerceptionSimulationManager.Interop libreria per visualizzare le classi e i metodi disponibili.  ad esempio:

  • IPerceptionSimulationManager2, che consente di aggiungere sink per ricevere dati di simulazione, caricare i dati di Scene Understanding, inviare dati audio e inserire richieste di convalida a livello di codice. 

    Nota

    Alcune funzionalità non sono attualmente supportate in HoloLens e Windows Mixed Reality.

  • ISimulatedSixDofController3, che consente di impostare la posizione dei pulsanti analogici nei controller di movimento.

  • ISimulationAudioVideoClient, che include i metodi per salvare le trame su disco. 

    Nota

    Per consentire il funzionamento dello streaming video in HoloLens, è necessario usare un dispositivo fisico oppure è necessario abilitare l'accelerazione grafica hardware nell'emulatore HoloLens 2.  L'emulatore tenta di abilitare l'accelerazione grafica hardware per impostazione predefinita.

  • ISimulationRecordingCallback2, che l'applicazione o il test può implementare per gestire le richieste di convalida durante la riproduzione delle registrazioni.

Per il codice C++ nativo:

  1. Includere le intestazioni corrette e PerceptionSimulationSettings.hPerceptionSimulationManager.h

  2. Collegare le librerie appropriate e PerceptionSimulationSettings.libPerceptionSimulationManager.lib almeno.  Se si usa la funzionalità Validators, è necessario anche PerceptionSimulationValidators.lib.  Se si usano le funzionalità audio/video, è necessario PerceptionSimulationOutput.lib

  3. Creare un PerceptionSimulationRestClient oggetto per un dispositivo HoloLens o un PC remoto Windows Mixed Reality oppure chiamare InstallSimulatedHeadset un dispositivo locale.  La InstallSimulatedHeadset funzione restituirà un ID visore VR che è possibile usare durante la creazione del flusso di controllo per comunicare con il dispositivo.

  4. Creare un flusso di controllo per il dispositivo.

  5. Creare un'istanza di Perception Simulation Manager.

Codice di esempio di base per l'inizializzazione della simulazione:

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