Simulação de percepção

Deseja criar um teste automatizado para seu aplicativo? Você deseja que seus testes vão além do teste de unidade no nível do componente e realmente exercite seu aplicativo de ponta a ponta? A Simulação de Percepção é o que você está procurando. A biblioteca de Simulação de Percepção envia dados de entrada humanos e mundiais para seu aplicativo para que você possa automatizar seus testes. Por exemplo, você pode simular a entrada de um humano olhando para uma posição específica e repetível e, em seguida, usar um gesto ou controlador de movimento.

A Simulação de Percepção pode enviar entradas simuladas como esta para um HoloLens físico, o emulador de HoloLens (primeira geração), o Emulator de HoloLens 2 ou um computador com Realidade Misturada Portal instalado. A Simulação de Percepção ignora os sensores dinâmicos em um dispositivo Realidade Misturada e envia entrada simulada para aplicativos em execução no dispositivo. Os aplicativos recebem esses eventos de entrada por meio das mesmas APIs que sempre usam e não podem diferenciar a execução com sensores reais versus a Simulação de Percepção. A Simulação de Percepção é a mesma tecnologia usada pelos emuladores de HoloLens para enviar entrada simulada para a máquina virtual HoloLens.

Para começar a usar a simulação em seu código, comece criando um objeto IPerceptionSimulationManager. Nesse objeto, você pode emitir comandos para controlar as propriedades de um "humano" simulado, incluindo posição da cabeça, posição da mão e gestos. Você também pode habilitar e manipular controladores de movimento.

Configurando um Visual Studio Project para a Simulação de Percepção

  1. Instale o emulador HoloLens no computador de desenvolvimento. O emulador inclui as bibliotecas que você usa para a Simulação de Percepção.
  2. Crie um novo projeto de área de trabalho Visual Studio C# (um console Project funciona muito bem para começar).
  3. Adicione os binários a seguir ao projeto como referências (Project-Add-Reference>>...). Você pode encontrá-los em %ProgramFiles(x86)%\Microsoft XDE\(version), como %ProgramFiles(x86)%\Microsoft XDE\10.0.18362.0 para o HoloLens 2 Emulator. (Observação: embora os binários fazem parte do Emulator 2 HoloLens, eles também funcionam para Windows Mixed Reality na área de trabalho.) a. PerceptionSimulationManager.Interop.dll – Wrapper C# gerenciado para a Simulação de Percepção. b. PerceptionSimulationRest.dll - Biblioteca para configurar um canal de comunicação de soquete da Web para o HoloLens ou emulador. c. SimulationStream.Interop.dll – Tipos compartilhados para simulação.
  4. Adicione o binário de implementação PerceptionSimulationManager.dll ao projeto a. Primeiro, adicione-o como um binário ao projeto (Project-Add-Existing>> Item...). Salve-o como um link para que ele não o copie para a pasta de origem do projeto. Add PerceptionSimulationManager.dll to the project as a link b. Em seguida, certifique-se de que ele seja copiado para sua pasta de saída no build. Isso está na folha de propriedades do binário. Mark PerceptionSimulationManager.dll to copy to the output directory
  5. Defina sua plataforma de solução ativa como x64. (Use o Configuration Manager para criar uma entrada de plataforma para x64 se ainda não existir.)

Criando um objeto IPerceptionSimulation Manager

Para controlar a simulação, você emitirá atualizações para objetos recuperados de um objeto IPerceptionSimulationManager. A primeira etapa é obter esse objeto e conectá-lo ao dispositivo de destino ou ao emulador. Você pode obter o endereço IP do emulador clicando no botão Portal do Dispositivo na barra de ferramentas

Open Device Portal iconAbrir portal de dispositivos: abre o Portal de Dispositivos do Windows para o SO HoloLens no emulador. Para Windows Mixed Reality, isso pode ser recuperado no aplicativo Configurações em "Atualizar & Segurança" e, em seguida, "Para desenvolvedores" na seção "Conexão usando:" em "Habilitar Portal do Dispositivo". Observe o endereço IP e a porta.

Primeiro, você chamará RestSimulationStreamSink.Create para obter um objeto RestSimulationStreamSink. Esse é o dispositivo de destino ou emulador que você controlará sobre uma conexão http. Seus comandos serão passados e manipulados pelo Windows Portal do Dispositivo em execução no dispositivo ou emulador. Os quatro parâmetros que você precisará para criar um objeto são:

  • Uri uri – endereço IP do dispositivo de destino (por exemplo, "https://123.123.123.123" ou "https://123.123.123.123:50080")
  • Credenciais do System.Net.NetworkCredential – Nome de usuário/senha para se conectar ao portal do dispositivo Windows no dispositivo ou emulador de destino. Se você estiver se conectando ao emulador por meio de seu endereço local (por exemplo, 168.... *) no mesmo computador, todas as credenciais serão aceitas.
  • bool normal – verdadeiro para prioridade normal, falso para baixa prioridade. Você geralmente deseja definir isso como verdadeiro para cenários de teste, o que permite que seu teste assuma o controle. O emulador e a simulação de Windows Mixed Reality usam conexões de baixa prioridade. Se o teste também usar uma conexão de baixa prioridade, a conexão estabelecida mais recentemente estará no controle.
  • Token System.Threading.CancellationToken – Token para cancelar a operação assíncrona.

Em segundo lugar, você criará o IPerceptionSimulationManager. Esse é o objeto que você usa para controlar a simulação. Isso também deve ser feito em um método assíncrono.

Controlar o humano simulado

Um IPerceptionSimulationManager tem uma propriedade Human que retorna um objeto ISimulatedHuman. Para controlar o humano simulado, execute operações neste objeto. Por exemplo:

manager.Human.Move(new Vector3(0.1f, 0.0f, 0.0f))

Aplicativo de console C# de exemplo básico

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.PerceptionSimulation;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Task.Run(async () =>
            {
                RestSimulationStreamSink sink = null;
                CancellationToken token = new System.Threading.CancellationToken();

                try
                {
                    sink = await RestSimulationStreamSink.Create(
                        // use the IP address for your device/emulator
                        new Uri("https://169.254.227.115"),
                        // no credentials are needed for the emulator
                        new System.Net.NetworkCredential("", ""),
                        // normal priorty
                        true,
                        // cancel token
                        token);

                    IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                // Always close the sink to return control to the previous application.
                if (sink != null)
                {
                    await sink.Close(token);
                }
            });

            // If main exits, the process exits.  
            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();
        }
    }
}

Aplicativo de console C# de exemplo estendido

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.PerceptionSimulation;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            RestSimulationStreamSink sink = null;
            CancellationToken token = new System.Threading.CancellationToken();

            Task.Run(async () =>
            {
                try
                {
                    sink = await RestSimulationStreamSink.Create(
                        // use the IP address for your device/emulator
                        new Uri("https://169.254.227.115"),
                        // no credentials are needed for the emulator
                        new System.Net.NetworkCredential("", ""),
                        // normal priorty
                        true,
                        // cancel token
                        token);

                    IPerceptionSimulationManager manager = PerceptionSimulationManager.CreatePerceptionSimulationManager(sink);

                    // Now, we'll simulate a sequence of actions.
                    // Sleeps in-between each action give time to the system
                    // to be able to properly react.
                    // This is just an example. A proper automated test should verify
                    // that the app has behaved correctly
                    // before proceeding to the next step, instead of using Sleeps.

                    // Activate the right hand
                    manager.Human.RightHand.Activated = true;

                    // Simulate Bloom gesture, which should cause Shell to disappear
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);

                    // Simulate Bloom gesture again... this time, Shell should reappear
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);

                    // Simulate a Head rotation down around the X axis
                    // This should cause gaze to aim about the center of the screen
                    manager.Human.Head.Rotate(new Rotation3(0.04f, 0.0f, 0.0f));
                    Thread.Sleep(300);

                    // Simulate a finger press & release
                    // Should cause a tap on the center tile, thus launching it
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(2000);

                    // Simulate a second finger press & release
                    // Should activate the app that was launched when the center tile was clicked
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(5000);

                    // Simulate a Head rotation towards the upper right corner
                    manager.Human.Head.Rotate(new Rotation3(-0.14f, 0.17f, 0.0f));
                    Thread.Sleep(300);

                    // Simulate a third finger press & release
                    // Should press the Remove button on the app
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerPressed);
                    Thread.Sleep(300);
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.FingerReleased);
                    Thread.Sleep(2000);

                    // Simulate Bloom gesture again... bringing the Shell back once more
                    manager.Human.RightHand.PerformGesture(SimulatedGesture.Home);
                    Thread.Sleep(2000);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            });

            // If main exits, the process exits.  
            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();

            // Always close the sink to return control to the previous application.
            if (sink != null)
            {
                sink.Close(token);
            }
        }
    }
}

Observação em controladores 6-DOF

Antes de chamar quaisquer propriedades em métodos em um controlador 6-DOF simulado, você deve ativar o controlador. Não fazer isso resultará em uma exceção. A partir do Atualização de maio de 2019 para o Windows 10, os controladores 6-DOF simulados podem ser instalados e ativados definindo a propriedade Status no objeto ISimulatedSixDofController para SimulatedSixDofControllerStatus.Active. No Atualização de outubro de 2018 para o Windows 10 e anterior, você deve instalar separadamente um controlador 6-DOF simulado primeiro chamando a ferramenta PerceptionSimulationDevice localizada na pasta \Windows\System32. O uso dessa ferramenta é o seguinte:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Por exemplo

    PerceptionSimulationDevice.exe i 6dof 1

As ações com suporte são:

  • i = instalar
  • q = consulta
  • r = remover

As instâncias com suporte são:

  • 1 = o controlador 6-DOF esquerdo
  • 2 = o controlador 6-DOF correto

O código de saída do processo indicará êxito (um valor de retorno zero) ou falha (um valor de retorno diferente de zero). Ao usar a ação 'q' para consultar se um controlador está instalado, o valor retornado será zero (0) se o controlador ainda não estiver instalado ou um (1) se o controlador estiver instalado.

Ao remover um controlador no Atualização de outubro de 2018 para o Windows 10 ou anterior, defina seu status como Desativado por meio da API primeiro e, em seguida, chame a ferramenta PerceptionSimulationDevice.

Essa ferramenta deve ser executada como Administrador.

Referência de API

Microsoft.PerceptionSimulation.SimulatedDeviceType

Descreve um tipo de dispositivo simulado

public enum SimulatedDeviceType
{
    Reference = 0
}

Microsoft.PerceptionSimulation.SimulatedDeviceType.Reference

Um dispositivo de referência fictício, o padrão para PerceptionSimulationManager

Microsoft.PerceptionSimulation.HeadTrackerMode

Descreve um modo de rastreador de cabeçalho

public enum HeadTrackerMode
{
    Default = 0,
    Orientation = 1,
    Position = 2
}

Microsoft.PerceptionSimulation.HeadTrackerMode.Default

Acompanhamento de cabeçalho padrão. Isso significa que o sistema pode selecionar o melhor modo de acompanhamento de cabeçalho com base nas condições de runtime.

Microsoft.PerceptionSimulation.HeadTrackerMode.Orientation

Acompanhamento somente de cabeçalho de orientação. Isso significa que a posição controlada pode não ser confiável e algumas funcionalidades dependentes da posição da cabeça podem não estar disponíveis.

Microsoft.PerceptionSimulation.HeadTrackerMode.Position

Acompanhamento de cabeçalho posicional. Isso significa que a posição e a orientação da cabeça rastreadas são confiáveis

Microsoft.PerceptionSimulation.SimulatedGesture

Descreve um gesto simulado

public enum SimulatedGesture
{
    None = 0,
    FingerPressed = 1,
    FingerReleased = 2,
    Home = 4,
    Max = Home
}

Microsoft.PerceptionSimulation.SimulatedGesture.None

Um valor sentinela usado para indicar nenhum gesto.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Um gesto pressionado pelo dedo.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Um gesto de dedo liberado.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

O gesto de início/sistema.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

O gesto máximo válido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

Os possíveis estados de um controlador 6-DOF simulado.

public enum SimulatedSixDofControllerStatus
{
    Off = 0,
    Active = 1,
    TrackingLost = 2,
}

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

O controlador 6-DOF está desativado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Active

O controlador 6-DOF está ativado e rastreado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

O controlador 6-DOF está ativado, mas não pode ser rastreado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton

Os botões com suporte em um controlador 6-DOF simulado.

public enum SimulatedSixDofControllerButton
{
    None = 0,
    Home = 1,
    Menu = 2,
    Grip = 4,
    TouchpadPress = 8,
    Select = 16,
    TouchpadTouch = 32,
    Thumbstick = 64,
    Max = Thumbstick
}

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.None

Um valor sentinela usado para indicar nenhum botão.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Home

O botão Página Inicial é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Menu

O botão Menu é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Grip

O botão Grip é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadPress

O TouchPad é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Select

O botão Selecionar é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.TouchpadTouch

O TouchPad é tocado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Thumbstick

O Thumbstick é pressionado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerButton.Max

O botão máximo válido.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState

O estado de calibragem dos olhos simulados

public enum SimulatedGesture
{
    Unavailable = 0,
    Ready = 1,
    Configuring = 2,
    UserCalibrationNeeded = 3
}

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Unavailable

A calibragem de olhos não está disponível.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Ready

Os olhos foram calibrados. Esse é o valor padrão.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.Configuring

Os olhos estão sendo calibrados.

Microsoft.PerceptionSimulation.SimulatedEyesCalibrationState.UserCalibrationNeeded

Os olhos precisam ser calibrados.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

A precisão de acompanhamento de uma articulação da mão.

public enum SimulatedHandJointTrackingAccuracy
{
    Unavailable = 0,
    Approximate = 1,
    Visible = 2
}

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Unavailable

A articulação não é rastreada.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Approximate

A posição conjunta é inferida.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy.Visible

A articulação é totalmente rastreada.

Microsoft.PerceptionSimulation.SimulatedHandPose

A precisão de acompanhamento de uma articulação da mão.

public enum SimulatedHandPose
{
    Closed = 0,
    Open = 1,
    Point = 2,
    Pinch = 3,
    Max = Pinch
}

Microsoft.PerceptionSimulation.SimulatedHandPose.Closed

As articulações dos dedos da mão são configuradas para refletir uma pose fechada.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

As articulações do dedo da mão são configuradas para refletir uma pose aberta.

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

As articulações dos dedos da mão são configuradas para refletir uma pose apontando.

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

As articulações dos dedos da mão são configuradas para refletir uma pose de pinçamento.

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

O valor máximo válido para SimulatedHandPose.

Microsoft.PerceptionSimulation.PlaybackState

Descreve o estado de uma reprodução.

public enum PlaybackState
{
    Stopped = 0,
    Playing = 1,
    Paused = 2,
    End = 3,
}

Microsoft.PerceptionSimulation.PlaybackState.Stopped

A gravação está parada no momento e pronta para reprodução.

Microsoft.PerceptionSimulation.PlaybackState.Playing

A gravação está sendo reproduzida no momento.

Microsoft.PerceptionSimulation.PlaybackState.Paused

A gravação está em pausa no momento.

Microsoft.PerceptionSimulation.PlaybackState.End

A gravação chegou ao fim.

Microsoft.PerceptionSimulation.Vector3

Descreve um vetor de três componentes, que pode descrever um ponto ou um vetor no espaço 3D.

public struct Vector3
{
    public float X;
    public float Y;
    public float Z;
    public Vector3(float x, float y, float z);
}

Microsoft.PerceptionSimulation.Vector3.X

O componente X do vetor.

Microsoft.PerceptionSimulation.Vector3.Y

O componente Y do vetor.

Microsoft.PerceptionSimulation.Vector3.Z

O componente Z do vetor.

Microsoft.PerceptionSimulation.Vector3.#ctor(System.Single, System.Single, System.Single)

Construa um novo Vector3.

Parâmetros

  • x – O componente x do vetor.
  • y – O componente y do vetor.
  • z – o componente z do vetor.

Microsoft.PerceptionSimulation.Rotation3

Descreve uma rotação de três componentes.

public struct Rotation3
{
    public float Pitch;
    public float Yaw;
    public float Roll;
    public Rotation3(float pitch, float yaw, float roll);
}

Microsoft.PerceptionSimulation.Rotation3.Pitch

O componente Pitch da Rotação, ao redor do eixo X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

O componente Yaw da Rotação, ao redor do eixo Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

O componente Roll da Rotação, ao redor do eixo Z.

Microsoft.PerceptionSimulation.Rotation3.#ctor(System.Single, System.Single, System.Single,System.Single)

Construa uma nova Rotação3.

Parâmetros

  • pitch – O componente de tom da Rotação.
  • yaw – o componente yaw da Rotação.
  • roll – o componente roll da Rotação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Descreve a configuração de uma articulação em uma mão simulada.

public struct SimulatedHandJointConfiguration
{
    public Vector3 Position;
    public Rotation3 Rotation;
    public SimulatedHandJointTrackingAccuracy TrackingAccuracy;
}

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Position

A posição da articulação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.Rotation

A rotação da articulação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration.TrackingAccuracy

A precisão de acompanhamento da articulação.

Microsoft.PerceptionSimulation.Frustum

Descreve um frusto de exibição, como normalmente usado por uma câmera.

public struct Frustum
{
    float Near;
    float Far;
    float FieldOfView;
    float AspectRatio;
}

Microsoft.PerceptionSimulation.Frustum.Near

A distância mínima contida no frusto.

Microsoft.PerceptionSimulation.Frustum.Far

A distância máxima contida no frusto.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

O campo de exibição horizontal do frusto, em radianos (menor que PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

A proporção do campo de exibição horizontal para o campo de exibição vertical.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Descreve a configuração da exibição do headset simulado.

public struct SimulatedDisplayConfiguration
{
    public Vector3 LeftEyePosition;
    public Rotation3 LeftEyeRotation;
    public Vector3 RightEyePosition;
    public Rotation3 RightEyeRotation;
    public float Ipd;
    public bool ApplyEyeTransforms;
    public bool ApplyIpd;
}

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyePosition

A transformação do centro da cabeça para o olho esquerdo para fins de renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.LeftEyeRotation

A rotação do olho esquerdo para fins de renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyePosition

A transformação do centro da cabeça para o olho direito para fins de renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.RightEyeRotation

A rotação do olho direito para fins de renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.Ipd

O valor do Ipd relatado pelo sistema para fins de renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Se os valores fornecidos para transformações de olho esquerdo e direito devem ser considerados válidos e aplicados ao sistema em execução.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Se o valor fornecido para Ipd deve ser considerado válido e aplicado ao sistema em execução.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager

Raiz para gerar os pacotes usados para controlar um dispositivo.

public interface IPerceptionSimulationManager
{   
    ISimulatedDevice Device { get; }
    ISimulatedHuman Human { get; }
    void Reset();
}

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Device

Recupere o objeto de dispositivo simulado que interpreta o humano simulado e o mundo simulado.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Human

Recupere o objeto que controla o humano simulado.

Microsoft.PerceptionSimulation.IPerceptionSimulationManager.Reset

Redefine a simulação para seu estado padrão.

Microsoft.PerceptionSimulation.ISimulatedDevice

Interface que descreve o dispositivo, que interpreta o mundo simulado e o humano simulado

public interface ISimulatedDevice
{
    ISimulatedHeadTracker HeadTracker { get; }
    ISimulatedHandTracker HandTracker { get; }
    void SetSimulatedDeviceType(SimulatedDeviceType type);
}

Microsoft.PerceptionSimulation.ISimulatedDevice.HeadTracker

Recupere o head tracker do dispositivo simulado.

Microsoft.PerceptionSimulation.ISimulatedDevice.HandTracker

Recupere o Rastreador de Mão do Dispositivo Simulado.

Microsoft.PerceptionSimulation.ISimulatedDevice.SetSimulatedDeviceType(Microsoft.PerceptionSimulation.SimulatedDeviceType)

Defina as propriedades do dispositivo simulado para corresponder ao tipo de dispositivo fornecido.

Parâmetros

  • tipo – O novo tipo de Dispositivo Simulado

Microsoft.PerceptionSimulation.ISimulatedDevice2

Propriedades adicionais estão disponíveis por meio da conversão do ISimulatedDevice para ISimulatedDevice2

public interface ISimulatedDevice2
{
    bool IsUserPresent { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    SimulatedDisplayConfiguration DisplayConfiguration { get; set; }

};

Microsoft.PerceptionSimulation.ISimulatedDevice2.IsUserPresent

Recupere ou defina se o humano simulado está usando ou não o fone de ouvido ativamente.

Microsoft.PerceptionSimulation.ISimulatedDevice2.DisplayConfiguration

Recupere ou defina as propriedades da exibição simulada.

Microsoft.PerceptionSimulation.ISimulatedHeadTracker

Interface que descreve a parte do dispositivo simulado que rastreia a cabeça do humano simulado.

public interface ISimulatedHeadTracker
{
    HeadTrackerMode HeadTrackerMode { get; set; }
};

Microsoft.PerceptionSimulation.ISimulatedHeadTracker.HeadTrackerMode

Recupera e define o modo de rastreador principal atual.

Microsoft.PerceptionSimulation.ISimulatedHandTracker

Interface que descreve a parte do dispositivo simulado que rastreia as mãos do humano simulado

public interface ISimulatedHandTracker
{
    Vector3 WorldPosition { get; }
    Vector3 Position { get; set; }
    float Pitch { get; set; }
    bool FrustumIgnored { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    Frustum Frustum { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedHandTracker.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Position

Recupere e defina a posição do rastreador de mão simulado em relação ao centro da cabeça.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Pitch

Recupere e defina o tom descendente do rastreador de mão simulado.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

Recupere e defina se o frusto do rastreador de mão simulado é ignorado. Quando ignorados, ambas as mãos são sempre visíveis. Quando não ignoradas (o padrão) as mãos só ficam visíveis quando estão dentro do frusto do rastreador de mão.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.Frustum

Recupere e defina as propriedades de frusto usadas para determinar se as mãos estão visíveis para o rastreador de mão simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman

Interface de nível superior para controlar o humano simulado.

public interface ISimulatedHuman 
{
    Vector3 WorldPosition { get; set; }
    float Direction { get; set; }
    float Height { get; set; }
    ISimulatedHand LeftHand { get; }
    ISimulatedHand RightHand { get; }
    ISimulatedHead Head { get; }s
    void Move(Vector3 translation);
    void Rotate(float radians);
}

Microsoft.PerceptionSimulation.ISimulatedHuman.WorldPosition

Recupere e defina a posição do nó com relação ao mundo, em metros. A posição corresponde a um ponto no centro dos pés do humano.

Microsoft.PerceptionSimulation.ISimulatedHuman.Direction

Recupere e defina a direção dos rostos humanos simulados no mundo. 0 radianos enfrenta o eixo Z negativo. Radianos positivos giram no sentido horário sobre o eixo Y.

Microsoft.PerceptionSimulation.ISimulatedHuman.Height

Recupere e defina a altura do humano simulado, em metros.

Microsoft.PerceptionSimulation.ISimulatedHuman.LeftHand

Recupere a mão esquerda do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman.RightHand

Recupere a mão direita do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman.Head

Recupere a cabeça do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman.Move(Microsoft.PerceptionSimulation.Vector3)

Mova o humano simulado em relação à sua posição atual, em metros.

Parâmetros

  • tradução – A tradução a ser movida em relação à posição atual.

Microsoft.PerceptionSimulation.ISimulatedHuman.Rotate(System.Single)

Girar o humano simulado em relação à sua direção atual, no sentido horário sobre o eixo Y

Parâmetros

  • radianos – a quantidade a ser girada ao redor do eixo Y.

Microsoft.PerceptionSimulation.ISimulatedHuman2

Propriedades adicionais estão disponíveis por meio da conversão do ISimulatedHuman para ISimulatedHuman2

public interface ISimulatedHuman2
{
    /* New members in addition to those available on ISimulatedHuman */
    ISimulatedSixDofController LeftController { get; }
    ISimulatedSixDofController RightController { get; }
}

Microsoft.PerceptionSimulation.ISimulatedHuman2.LeftController

Recupere o controlador 6-DOF esquerdo.

Microsoft.PerceptionSimulation.ISimulatedHuman2.RightController

Recupere o controlador 6-DOF correto.

Microsoft.PerceptionSimulation.ISimulatedHand

Interface que descreve uma mão do humano simulado

public interface ISimulatedHand
{
    Vector3 WorldPosition { get; }
    Vector3 Position { get; set; }
    bool Activated { [return: MarshalAs(UnmanagedType.Bool)] get; [param: MarshalAs(UnmanagedType.Bool)] set; }
    bool Visible { [return: MarshalAs(UnmanagedType.Bool)] get; }
    void EnsureVisible();
    void Move(Vector3 translation);
    void PerformGesture(SimulatedGesture gesture);
}

Microsoft.PerceptionSimulation.ISimulatedHand.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedHand.Position

Recupere e defina a posição da mão simulada em relação ao humano, em metros.

Microsoft.PerceptionSimulation.ISimulatedHand.Activated

Recupere e defina se a mão está ativada no momento.

Microsoft.PerceptionSimulation.ISimulatedHand.Visible

Recupere se a mão está atualmente visível para o SimulatedDevice (ou seja, se está em uma posição a ser detectada pelo HandTracker).

Microsoft.PerceptionSimulation.ISimulatedHand.EnsureVisible

Mova a mão de modo que ela esteja visível para o SimulatedDevice.

Microsoft.PerceptionSimulation.ISimulatedHand.Move(Microsoft.PerceptionSimulation.Vector3)

Mova a posição da mão simulada em relação à sua posição atual, em metros.

Parâmetros

  • tradução – O valor para traduzir a mão simulada.

Microsoft.PerceptionSimulation.ISimulatedHand.PerformGesture(Microsoft.PerceptionSimulation.SimulatedGesture)

Execute um gesto usando a mão simulada. Ele só será detectado pelo sistema se a mão estiver habilitada.

Parâmetros

  • gesto – O gesto a ser executado.

Microsoft.PerceptionSimulation.ISimulatedHand2

Propriedades adicionais estão disponíveis lançando um ISimulatedHand para ISimulatedHand2.

public interface ISimulatedHand2
{
    /* New members in addition to those available on ISimulatedHand */
    Rotation3 Orientation { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedHand2.Orientation

Recupere ou defina a rotação da mão simulada. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedHand3

Propriedades adicionais estão disponíveis por meio da conversão de um ISimulatedHand para ISimulatedHand3

public interface ISimulatedHand3
{
    /* New members in addition to those available on ISimulatedHand and ISimulatedHand2 */
    GetJointConfiguration(SimulatedHandJoint joint, out SimulatedHandJointConfiguration jointConfiguration);
    SetJointConfiguration(SimulatedHandJoint joint, SimulatedHandJointConfiguration jointConfiguration);
    SetHandPose(SimulatedHandPose pose, bool animate);
}

Microsoft.PerceptionSimulation.ISimulatedHand3.GetJointConfiguration

Obtenha a configuração conjunta da junta especificada.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetJointConfiguration

Defina a configuração conjunta para a junta especificada.

Microsoft.PerceptionSimulation.ISimulatedHand3.SetHandPose

Defina a mão para uma pose conhecida com um sinalizador opcional para animar. Observação: animar não resultará em articulações refletindo imediatamente suas configurações de conjunto final.

Microsoft.PerceptionSimulation.ISimulatedHead

Interface que descreve a cabeça do humano simulado.

public interface ISimulatedHead
{
    Vector3 WorldPosition { get; }
    Rotation3 Rotation { get; set; }
    float Diameter { get; set; }
    void Rotate(Rotation3 rotation);
}

Microsoft.PerceptionSimulation.ISimulatedHead.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedHead.Rotation

Recupere a rotação da cabeça simulada. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedHead.Diameter

Recupere o diâmetro da cabeça simulada. Esse valor é usado para determinar o centro da cabeça (ponto de rotação).

Microsoft.PerceptionSimulation.ISimulatedHead.Rotate(Microsoft.PerceptionSimulation.Rotation3)

Gire a cabeça simulada em relação à rotação atual. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Parâmetros

  • rotação – O valor a ser girado.

Microsoft.PerceptionSimulation.ISimulatedHead2

Propriedades adicionais estão disponíveis por meio da conversão de um ISimulatedHead para ISimulatedHead2

public interface ISimulatedHead2
{
    /* New members in addition to those available on ISimulatedHead */
    ISimulatedEyes Eyes { get; }
}

Microsoft.PerceptionSimulation.ISimulatedHead2.Eyes

Recupere os olhos do humano simulado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController

Interface que descreve um controlador 6-DOF associado ao humano simulado.

public interface ISimulatedSixDofController
{
    Vector3 WorldPosition { get; }
    SimulatedSixDofControllerStatus Status { get; set; }
    Vector3 Position { get; }
    Rotation3 Orientation { get; set; }
    void Move(Vector3 translation);
    void PressButton(SimulatedSixDofControllerButton button);
    void ReleaseButton(SimulatedSixDofControllerButton button);
    void GetTouchpadPosition(out float x, out float y);
    void SetTouchpadPosition(float x, float y);
}

Microsoft.PerceptionSimulation.ISimulatedSixDofController.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Status

Recupere ou defina o estado atual do controlador. O status do controlador deve ser definido como um valor diferente de Off antes que qualquer chamada para mover, girar ou pressionar botões seja bem-sucedida.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Position

Recupere ou defina a posição do controlador simulado em relação ao humano, em metros.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Orientation

Recupere ou defina a orientação do controlador simulado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.Move(Microsoft.PerceptionSimulation.Vector3)

Mova a posição do controlador simulado em relação à sua posição atual, em metros.

Parâmetros

  • tradução – O valor para traduzir o controlador simulado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.PressButton(SimulatedSixDofControllerButton)

Pressione um botão no controlador simulado. Ele só será detectado pelo sistema se o controlador estiver habilitado.

Parâmetros

  • botão – O botão a ser pressionado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.ReleaseButton(SimulatedSixDofControllerButton)

Libere um botão no controlador simulado. Ele só será detectado pelo sistema se o controlador estiver habilitado.

Parâmetros

  • botão – O botão a ser liberado.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.GetTouchpadPosition(out float, out float)

Obtenha a posição de um dedo simulado no touchpad do controlador simulado.

Parâmetros

  • x – A posição horizontal do dedo.
  • y - A posição vertical do dedo.

Microsoft.PerceptionSimulation.ISimulatedSixDofController.SetTouchpadPosition(float, float)

Defina a posição de um dedo simulado no touchpad do controlador simulado.

Parâmetros

  • x – A posição horizontal do dedo.
  • y - A posição vertical do dedo.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2

Propriedades e métodos adicionais estão disponíveis por meio da conversão de um ISimulatedSixDofController para ISimulatedSixDofController2

public interface ISimulatedSixDofController2
{
    /* New members in addition to those available on ISimulatedSixDofController */
    void GetThumbstickPosition(out float x, out float y);
    void SetThumbstickPosition(float x, float y);
    float BatteryLevel { get; set; }
}

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.GetThumbstickPosition(out float, out float)

Obtenha a posição do polegar simulado no controlador simulado.

Parâmetros

  • x - A posição horizontal do polegar.
  • y - A posição vertical do polegar.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.SetThumbstickPosition(float, float)

Defina a posição do thumbstick simulado no controlador simulado.

Parâmetros

  • x - A posição horizontal do polegar.
  • y - A posição vertical do polegar.

Microsoft.PerceptionSimulation.ISimulatedSixDofController2.BatteryLevel

Recupere ou defina o nível de bateria do controlador simulado. O valor deve ser maior que 0,0 e menor que ou igual a 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Interface que descreve os olhos do humano simulado.

public interface ISimulatedEyes
{
    Rotation3 Rotation { get; set; }
    void Rotate(Rotation3 rotation);
    SimulatedEyesCalibrationState CalibrationState { get; set; }
    Vector3 WorldPosition { get; }
}

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotation

Recupere a rotação dos olhos simulados. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedEyes.Rotate(Microsoft.PerceptionSimulation.Rotation3)

Gire os olhos simulados em relação à rotação atual. Radianos positivos giram no sentido horário ao olhar ao longo do eixo.

Parâmetros

  • rotação - A quantidade a girar.

Microsoft.PerceptionSimulation.ISimulatedEyes.CalibrationState

Recupera ou define o estado de calibragem dos olhos simulados.

Microsoft.PerceptionSimulation.ISimulatedEyes.WorldPosition

Recupere a posição do nó com relação ao mundo, em metros.

Microsoft.PerceptionSimulation.ISimulationRecording

Interface para interagir com uma única gravação carregada para reprodução.

public interface ISimulationRecording
{
    StreamDataTypes DataTypes { get; }
    PlaybackState State { get; }
    void Play();
    void Pause();
    void Seek(UInt64 ticks);
    void Stop();
};

Microsoft.PerceptionSimulation.ISimulationRecording.DataTypes

Recupera a lista de tipos de dados na gravação.

Microsoft.PerceptionSimulation.ISimulationRecording.State

Recupera o estado atual da gravação.

Microsoft.PerceptionSimulation.ISimulationRecording.Play

Inicie a reprodução. Se a gravação for pausada, a reprodução será retomada do local em pausa; se interrompida, a reprodução começará no início. Se já estiver jogando, essa chamada será ignorada.

Microsoft.PerceptionSimulation.ISimulationRecording.Pause

Pausa a reprodução em seu local atual. Se a gravação for interrompida, a chamada será ignorada.

Microsoft.PerceptionSimulation.ISimulationRecording.Seek(System.UInt64)

Busca a gravação para a hora especificada (em intervalos de 100 nanossegundos desde o início) e pausa nesse local. Se a hora estiver além do final da gravação, ela será pausada no último quadro.

Parâmetros

  • tiques - O tempo para o qual procurar.

Microsoft.PerceptionSimulation.ISimulationRecording.Stop

Interrompe a reprodução e redefine a posição para o início.

Microsoft.PerceptionSimulation.ISimulationRecordingCallback

Interface para receber alterações de estado durante a reprodução.

public interface ISimulationRecordingCallback
{
    void PlaybackStateChanged(PlaybackState newState);
};

Microsoft.PerceptionSimulation.ISimulationRecordingCallback.PlaybackStateChanged(Microsoft.PerceptionSimulation.PlaybackState)

Chamado quando o estado de reprodução de um ISimulationRecording foi alterado.

Parâmetros

  • newState - O novo estado da gravação.

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Objeto raiz para criar objetos de Simulação de Percepção.

public static class PerceptionSimulationManager
{
    public static IPerceptionSimulationManager CreatePerceptionSimulationManager(ISimulationStreamSink sink);
    public static ISimulationStreamSink CreatePerceptionSimulationRecording(string path);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory);
    public static ISimulationRecording LoadPerceptionSimulationRecording(string path, ISimulationStreamSinkFactory factory, ISimulationRecordingCallback callback);

Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationManager(Microsoft.PerceptionSimulation.ISimulationStreamSink)

Crie um objeto para gerar pacotes simulados e entregá-los ao coletor fornecido.

Parâmetros

  • coletor - O coletor que receberá todos os pacotes gerados.

Valor retornado

O Gerenciador criado.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.CreatePerceptionSimulationRecording(System.String)

Crie um coletor, que armazena todos os pacotes recebidos em um arquivo no caminho especificado.

Parâmetros

  • caminho – O caminho do arquivo a ser criado.

Valor retornado

O coletor criado.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.LoadPerceptionSimulationRecording(System.String, Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory)

Carregue uma gravação do arquivo especificado.

Parâmetros

  • caminho – O caminho do arquivo a ser carregado.
  • factory - Uma fábrica usada pela gravação para criar um ISimulationStreamSink quando necessário.

Valor retornado

A gravação carregada.

Microsoft.PerceptionSimulation.PerceptionSimulationManager.LoadPerceptionSimulationRecording(System.String, Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory,Microsoft.PerceptionSimulation.ISimulationRecordingCallback)

Carregue uma gravação do arquivo especificado.

Parâmetros

  • caminho – O caminho do arquivo a ser carregado.
  • factory - Uma fábrica usada pela gravação para criar um ISimulationStreamSink quando necessário.
  • retorno de chamada – um retorno de chamada, que recebe atualizações regravando o status da gravação.

Valor retornado

A gravação carregada.

Microsoft.PerceptionSimulation.StreamDataTypes

Descreve os diferentes tipos de dados de fluxo.

public enum StreamDataTypes
{
    None = 0x00,
    Head = 0x01,
    Hands = 0x02,
    SpatialMapping = 0x08,
    Calibration = 0x10,
    Environment = 0x20,
    SixDofControllers = 0x40,
    Eyes = 0x80,
    DisplayConfiguration = 0x100
    All = None | Head | Hands | SpatialMapping | Calibration | Environment | SixDofControllers | Eyes | DisplayConfiguration
}

Microsoft.PerceptionSimulation.StreamDataTypes.None

Um valor sentinela usado para indicar nenhum tipo de dados de fluxo.

Microsoft.PerceptionSimulation.StreamDataTypes.Head

Fluxo de dados para a posição e orientação da cabeça.

Microsoft.PerceptionSimulation.StreamDataTypes.Hands

Fluxo de dados para a posição e gestos das mãos.

Microsoft.PerceptionSimulation.StreamDataTypes.SpatialMapping

Fluxo de dados para mapeamento espacial do ambiente.

Microsoft.PerceptionSimulation.StreamDataTypes.Calibration

Fluxo de dados para calibragem do dispositivo. Os pacotes de calibragem são aceitos apenas por um sistema no Modo Remoto.

Microsoft.PerceptionSimulation.StreamDataTypes.Environment

Fluxo de dados para o ambiente do dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.SixDofControllers

Fluxo de dados para controladores de movimento.

Microsoft.PerceptionSimulation.StreamDataTypes.Eyes

Fluxo de dados com os olhos do humano simulado.

Microsoft.PerceptionSimulation.StreamDataTypes.DisplayConfiguration

Fluxo de dados com a configuração de exibição do dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.All

Um valor sentinela usado para indicar todos os tipos de dados registrados.

Microsoft.PerceptionSimulation.ISimulationStreamSink

Um objeto que recebe pacotes de dados de um fluxo de simulação.

public interface ISimulationStreamSink
{
    void OnPacketReceived(uint length, byte[] packet);
}

Microsoft.PerceptionSimulation.ISimulationStreamSink.OnPacketReceived(uint length, byte[] packet)

Recebe um único pacote, que é digitado internamente e com versão.

Parâmetros

  • comprimento – o comprimento do pacote.
  • pacote – Os dados do pacote.

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory

Um objeto que cria ISimulationStreamSink.

public interface ISimulationStreamSinkFactory
{
    ISimulationStreamSink CreateSimulationStreamSink();
}

Microsoft.PerceptionSimulation.ISimulationStreamSinkFactory.CreateSimulationStreamSink()

Cria uma única instância de ISimulationStreamSink.

Valor retornado

O coletor criado.