Compartir a través de

Simulación de percepción (versión preliminar)

Haga clic en el vínculo siguiente para descargar el paquete independiente Perception Simulation:

Simulación de percepción (versión preliminar)

Esta versión de paquete independiente de Perception Simulation permite actualizaciones más frecuentes independientemente de las versiones del sistema operativo y aporta nuevas características, entre las que se incluyen:

  • Grabación y reproducción: La capacidad de grabar acciones realizadas con Perception Simulation para su reproducción de forma automatizada con código mínimo.

  • Validadores: Durante la reproducción de grabaciones, Perception Simulation puede volver a llamar al código de prueba, donde puede validar el estado mediante metadatos incrustados en la grabación.

  • Streaming de vídeo: La interfaz de usuario de Perception Simulation Control puede mostrar una vista en directo de HoloLens 2 dispositivo o emulador y permitir el control directo mediante teclado, mouse o controlador para juegos, que es similar al emulador de HoloLens 2. También se proporciona una API de cliente de vídeo para permitir que las pruebas automatizadas capturen capturas de pantalla.

  • API nativa completa: Además de seguir proporcionando una API de cliente de código administrado, esta versión incluye encabezados y bibliotecas para la simulación de percepción extendida o para escribir pruebas en C++.

  • Nuevo cliente REST: Al conectarse a un dispositivo remoto, el nuevo cliente REST nativo proporciona una mayor solidez y permite el acceso desde código nativo y administrado.

Requisitos del sistema

  • 60 MB de espacio en disco

  • Windows 10, versión 2004 o posterior

Nota

Esta versión de Perception Simulation instala y ejecuta en paralelo con la versión contenida en los sistemas operativos Windows 10 y 11. El acceso directo al Control de simulación de percepción en el menú Inicio se iniciará y usará esta versión preliminar, que se almacena en \Program Files\Microsoft Perception Simulation. Si inicia herramientas de desarrollo desde Mixed Reality Portal, el emulador de HoloLens 2 o desde \Windows\System32\PerceptionSimulation, ejecutará la versión anterior. Para usar esta versión preliminar, asegúrese de compilar cualquier código de prueba mediante los ensamblados de referencia o encabezados y bibliotecas en \Program Files\Microsoft Perception Simulation.

Nota

Esta versión es compatible con HoloLens 2 sin instalar nada nuevo en el casco HoloLens 2. Una actualización futura de HoloLens 2 habilitará la característica Scene Understanding en esta versión preliminar.

Instalación

El instalador de versión preliminar instalará los siguientes componentes:

  • La aplicación Control de simulación de percepción: Esta aplicación es la interfaz de usuario para controlar manualmente la simulación y crear grabaciones.

  • Los controladores de simulación de percepción: Esto incluye el controlador Perception Simulation Headset y el controlador Perception Simulation 6-DOF Controller. Ambos controladores se usan para Windows Mixed Reality.

  • Grabaciones de asignaciones espaciales para su uso con HoloLens 2: estas son las mismas grabaciones que se proporcionan con el emulador de HoloLens 2.

  • Capturas de la sala de comprensión de escenas: Se habilitarán en una actualización futura HoloLens 2.

  • Sdk nativo de simulación de percepción: Esto incluye encabezados y bibliotecas de C++ que permiten escribir herramientas, aplicaciones y probar la automatización que controlan la simulación de percepción mediante programación desde código nativo.

  • SDK administrado de Perception Simulation: Esto incluye ensamblados de referencia administrados que habilitan la escritura de herramientas, aplicaciones y automatización de pruebas que controlan la simulación de percepción mediante programación desde código administrado.

Control manual

Para controlar Windows Mixed Reality o HoloLens 2 mediante teclado, mouse o controlador para juegos:

  1. Inicie la aplicación Control de simulación de percepción .

  2. Seleccione el producto de destino en la lista desplegable de la parte superior de la ventana. Para esta versión, use HoloLens 2 (heredado) para dispositivos HoloLens 2 existentes.

  3. En el caso de un dispositivo remoto, como HoloLens, escriba la dirección IP del dispositivo o emulador de HoloLens.

    Asegúrese de que Device Portal está habilitado en el dispositivo de destino.  Esto está habilitado de forma predeterminada en el emulador de HoloLens 2, pero tendrá que habilitarse manualmente en un dispositivo HoloLens físico o en el equipo de destino al usar Windows Mixed Reality (remoto).

  4. Cambie el conmutador Auriculares a Activado.

Creación de una grabación

Puede crear una grabación de acciones manuales de simulación de percepción mediante la aplicación Control de simulación de percepción y, a continuación, reproducir la grabación manualmente o en una prueba automatizada:

  1. Conéctese al dispositivo de destino.

  2. Desplácese hacia abajo hasta que vea la sección Grabaciones .

  3. Presione el botón Grabar .

  4. Seleccione una carpeta y asigne un nombre de archivo a la grabación.

  5. Realice sus acciones en la experiencia de usuario manualmente mediante el control de simulación de percepción : busque alrededor, interactúe, etc.

    Durante la grabación, opcionalmente puede insertar un paso de validación en la grabación: seleccione el botón Agregar validación y, a continuación, rellene la interfaz de usuario emergente que aparece.

  6. Seleccione el botón Detener.  La nueva grabación se guardará en el disco y se cargará automáticamente.  Presione Play (Reproducir ) para reproducir las acciones.

Creación de automatización de pruebas

Para crear la automatización de pruebas mediante código administrado:

  1. Cree un proyecto de código administrado de .NET Framework 4.7 en Visual Studio.

  2. Agregue referencias a PerceptionSimulation.Interopy SimulationStream.InteropPerceptionSimulationManager.Interop .  Los encontrará en la carpeta del SDK administrado (%ProgramFiles%\Microsoft Perception Simulation\Sdk\References).

  3. Agregue un vínculo de elemento existente en el proyecto de código administrado a PerceptionSimulationManager.dll y establézcalo en Copiar si es más reciente.

  4. Agregue using Microsoft.PerceptionSimulation.

Este es el código básico de C# de ejemplo que se conecta a un dispositivo HoloLens remoto, ejecuta un gesto inicio (sistema) y, a continuación, reproduce una grabación:

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

Esto es similar al código de ejemplo existente, pero usa el nuevo ISimulationRestClient en v3.  Este cliente implementa ISimulationStreamSinkFactory y, por tanto, es adecuado para obtener receptores para los métodos que los requieren.

En el ejemplo siguiente se hace lo mismo que el anterior, pero se conecta a Windows Mixed Reality en el equipo local:

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

Los identificadores de plataforma se almacenan en el registro en HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Perception Simulation\Platforms.  Los nombres de clave no se usan, pero el valor de id. dentro es.  Por ejemplo, el identificador de plataforma de Windows Mixed Reality está en HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Perception Simulation\Platforms\WMR  (ID = "B1DE8CAA-898F-474F-811A-F041FE3FD40D").  Puede enumerar plataformas en el código mediante PerceptionSimulationManager.GetAvailablePlatforms() el uso de que devuelve una matriz de SimulationPlatform estructuras.  Cada SimulationPlatform una proporciona varios detalles sobre la plataforma, incluido .PlatformId  En el caso del código nativo, PerceptionSimulationSettings::GetAvailablePlatforms() se puede usar.  La versión nativa de la API devuelve un recuento y, opcionalmente, rellena la matriz proporcionada por el autor de la llamada. Puede llamar a la API una vez para obtener el recuento y, a continuación, llamarlo de nuevo para que la matriz se rellene.

Puede examinar la PerceptionSimulationManager.Interop biblioteca para ver las clases y los métodos disponibles.  Esto incluye:

  • IPerceptionSimulationManager2, que permite agregar receptores para recibir datos de simulación, cargar datos de Scene Understanding, enviar datos de audio e insertar solicitudes de validación mediante programación. 

    Nota

    Algunas características no se admiten actualmente en HoloLens y Windows Mixed Reality.

  • ISimulatedSixDofController3, que permite establecer la posición de los botones analógicos en los controladores de movimiento.

  • ISimulationAudioVideoClient, que incluye métodos para guardar texturas en el disco. 

    Nota

    Para que el streaming de vídeo funcione en HoloLens, debe usar un dispositivo físico o debe tener habilitada la aceleración de gráficos de hardware en el emulador de HoloLens 2.  El emulador intenta habilitar la aceleración de gráficos de hardware de forma predeterminada.

  • ISimulationRecordingCallback2, que la prueba o la aplicación pueden implementar para controlar las solicitudes de validación durante la reproducción de grabaciones.

Para el código nativo de C++:

  1. Incluir los encabezados correctos: PerceptionSimulationSettings.h y PerceptionSimulationManager.h

  2. Vincule las bibliotecas adecuadas, PerceptionSimulationSettings.lib y PerceptionSimulationManager.lib como mínimo.  Si usa la característica Validators, también necesitará PerceptionSimulationValidators.lib.  Si usa las características de audio/vídeo, necesitará PerceptionSimulationOutput.lib.

  3. Cree un PerceptionSimulationRestClient para un dispositivo HoloLens o un equipo remoto Windows Mixed Reality o llame a InstallSimulatedHeadset para un dispositivo local.  La InstallSimulatedHeadset función devolverá un identificador de casco que puede usar al crear la secuencia de control para comunicarse con el dispositivo.

  4. Cree una secuencia de control para el dispositivo.

  5. Cree una instancia de Perception Simulation Manager.

Código de ejemplo básico para inicializar la simulación:

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