Simulação de perceção

Deseja construir um teste automatizado para a sua aplicação? Deseja que os seus testes ultrapassem os testes de unidade de nível de componente e exerçam realmente a sua aplicação de ponta a ponta? A Simulação da Perceção é o que procuras. A biblioteca Perception Simulation envia dados de entrada humana e mundial para a sua aplicação para que possa automatizar os seus testes. Por exemplo, 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.

Perception Simulation pode enviar entradas simuladas como esta para um HoloLens físico, o emulador HoloLens (primeira geração), o HoloLens 2 Emulator ou um PC com Portal de Realidade Mista instalado. Perception Simulation contorna os sensores vivos num dispositivo de Realidade Mista e envia entrada simulada para aplicações em execução no dispositivo. As aplicações recebem estes eventos de entrada através das mesmas APIs que usam sempre e não conseguem distinguir entre correr com sensores reais versus Perception Simulation. Perception Simulation é a mesma tecnologia usada pelos emuladores HoloLens para enviar entrada simulada para a máquina virtual HoloLens.

Para começar a usar a simulação no seu código, comece por criar um objeto IPerceptionSimulationSimager. A partir desse objeto, pode emitir comandos para controlar propriedades de um "humano" simulado, incluindo posição da cabeça, posição da mão e gestos. Também pode ativar e manipular controladores de movimento.

Configuração de um Visual Studio Project para simulação de perceção

  1. Instale o emulador HoloLens no seu PC de desenvolvimento. O emulador inclui as bibliotecas que utiliza para a Simulação de Perceção.
  2. Crie um novo projeto de desktop Visual Studio C #(um Project de consola funciona muito bem para começar).
  3. Adicione os seguintes binários ao seu projeto como referências (Project- >> Add-Reference...). Pode encontrá-los em %ProgramFiles(x86%\Microsoft XDE\(versão), tais como > para o HoloLens 2 Emulator. (Nota: embora os binários faziam parte do HoloLens 2 Emulator, também trabalham para Windows Mixed Reality no ambiente de trabalho.) a. PerceptionSimulationManager.Interop.dll - Invólucro C# gerido para simulação de perceção. b. PerceptionSimulationRest.dll - Biblioteca para a criação de um canal de comunicação web-socket para o HoloLens ou emulador. c. SimulationStream.Interop.dll - Tipos partilhados para simulação.
  4. Adicione o PerceptionSimulationManager.dll binário de implementação ao seu projeto a. Primeiro adicione-o como binário ao projeto (Project- > Add- > Item existente...). Guarde-o como um link para que não o copie para a sua pasta de origem do projeto. Adicione PerceptionSimulationManager.dll ao projeto como um link b. Em seguida, certifique-se de que é copiado para a sua pasta de saída na construção. Isto está na folha de propriedade do binário. Mark PerceptionSimulationManager.dll para copiar para o diretório de saída
  5. Desaça a sua plataforma de solução ativa para x64. (Utilize o Gestor de Configuração para criar uma entrada de Plataforma para x64 se já não existir.)

Criação de um objeto de gestor de IPerceptionSimulation

Para controlar a simulação, irá emitir atualizações a objetos recuperados a partir de um objeto IPerceptionSimulationManager. O primeiro passo é obter esse objeto e conectá-lo ao dispositivo alvo ou ao emulador. Pode obter o endereço IP do seu emulador clicando no botão Portal do Dispositivo na barra de ferramentas

Abra o ícone do portal do dispositivoOpen DevicePortal: Abra o portal do dispositivo Windows para o HoloLens OS no emulador. Para Windows Mixed Reality, esta pode ser recuperada na aplicação Definições em "Update & Security", em seguida, "Para os desenvolvedores" na secção "Ligação usando:" em "Enable Device Portal". Certifique-se de que nota tanto o endereço IP como a porta.

Em primeiro lugar, vai chamar RestSimulationStreamSink.Create para obter um objeto RestSimulationStreamSink. Este é o dispositivo alvo ou emulador que irá controlar sobre uma ligação http. Os seus comandos serão transmitidos e manuseados pelo Portal do Dispositivo Windows em funcionamento no dispositivo ou no emulador. Os quatro parâmetros que precisa para criar um objeto são:

  • Uri uri - Endereço IP do dispositivo-alvo (por exemplo, " https://123.123.123.123" ; ou " https://123.123.123.123:50080" ;)
  • Credenciais System.Net.NetworkCredential - Nome de utilizador/palavra-passe para ligar ao Portal do Dispositivo Windows no dispositivo-alvo ou no emulador. Se estiver a ligar-se ao emulador através do seu endereço local (por exemplo, 168.. . *) no mesmo PC, quaisquer credenciais serão aceites.
  • bool normal - Verdade para a prioridade normal, falso para baixa prioridade. Geralmente, pretende definir isto para cenários de teste, o que permite que o seu teste assuma o controlo. O emulador e a simulação Windows Mixed Reality utilizam ligações de baixa prioridade. Se o seu teste também utilizar uma ligação de baixa prioridade, a ligação mais recentemente estabelecida estará no controlo.
  • System.Threading.CancelamentoToken token - Token para cancelar a operação async.

Segundo, vai criar o IPerceptionSimulationSimager. Este é o objeto que usa para controlar a simulação. Isto também deve ser feito num método assíduo.

Controle o Humano simulado

Um IPerceptionSimulationManager tem uma propriedade humana que devolve um objeto ISimulado Humano. Para controlar o humano simulado, execute operações neste objeto. Por exemplo:

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

Aplicação básica da consola C# da amostra

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

Aplicação de consola Sº da Amostra Alargada C#

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

Nota sobre controladores 6-DOF

Antes de ligar para quaisquer propriedades sobre métodos num controlador simulado de 6-DOF, deve ativar o controlador. Não fazê-lo resultará numa exceção. A partir do Atualização de maio de 2019 do Windows 10, os controladores simulados de 6-DOF podem ser instalados e ativados definindo a propriedade Status no objeto ISimultedSixDofController para SimulaçãoSixDofControllerStatus.Ative. Na Atualização de outubro de 2018 do Windows 10 e antes, deve instalar separadamente um controlador simulado de 6-DOF primeiro, chamando a ferramenta PerceptionSimulationDevice localizada na pasta \Windows\System32. A utilização desta ferramenta é a seguinte:

    PerceptionSimulationDevice.exe <action> 6dof <instance>

Por exemplo

    PerceptionSimulationDevice.exe i 6dof 1

As ações apoiadas são:

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

As instâncias apoiadas são:

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

O código de saída do processo indicará o sucesso (um valor de retorno zero) ou uma falha (um valor de retorno não zero). Ao utilizar a ação 'q' para saber se um controlador está instalado, o valor de retorno 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 do Windows 10 ou mais cedo, defina primeiro o seu estado através da API e, em seguida, chame a ferramenta PerceptionSimulationDevice.

Esta ferramenta tem de ser executada como Administradora.

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ça

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

Microsoft.perceptionSimulation.HeadTrackerMode.prede

Rastreio de cabeça padrão. Isto significa que o sistema pode selecionar o melhor modo de rastreio da cabeça com base em condições de tempo de execução.

Microsoft.PerceptionSimulation.HeadTrackerMode.orientation

Orientação apenas rastreio de cabeça. Isto significa que a posição rastreada pode não ser fiável, e alguma funcionalidade dependente da posição da cabeça pode não estar disponível.

Microsoft.perceptionSimulation.HeadTrackerMode.position

Rastreio posicional da cabeça. Isto significa que a posição e orientação da cabeça rastreadas são ambas fiá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 de sentinela usado para indicar nenhum gesto.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerPressed

Um gesto com um dedo pressionado.

Microsoft.PerceptionSimulation.SimulatedGesture.FingerReleased

Um gesto de libertação de um dedo.

Microsoft.PerceptionSimulation.SimulatedGesture.Home

O gesto casa/sistema.

Microsoft.PerceptionSimulation.SimulatedGesture.Max

O gesto máximo válido.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus

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

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

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Off

O controlador 6-DOF está desligado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.Ative

O controlador 6-DOF é ligado e rastreado.

Microsoft.PerceptionSimulation.SimulatedSixDofControllerStatus.TrackingLost

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

Microsoft.PerceptionSimulation.simulatedsixdofControllerButton

Os botões suportados num controlador simulado de 6-DOF.

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 de sentinela usado para indicar que não há botões.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.home

O botão Home é premido.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.menu

O botão Menu é premido.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.Grip

O botão Grip é premido.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.touchpadPress

O TouchPad é pressionado.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.select

O botão Select é premido.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.touchpadTouch

O TouchPad é tocado.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.thumbstick

O polegar é pressionado.

Microsoft.perceptionSimulation.simulatedsixdofControllerButton.max

O botão máximo válido.

Microsoft.PerceptionSimulation.simulatedEyesCalibrationState

O estado de calibração dos olhos simulados

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

Microsoft.perceptionSimulation.simulatedEyesCalibrationState.indisponível

A calibração dos olhos não está disponível.

Microsoft.perceptionSimulation.simulatedEyesCalibrationState.ready

Os olhos foram calibrados. Este é o valor predefinido.

Microsoft.PerceptionSimulation.simulatedEyesCalibrationState.configurar

Os olhos estão a ser calibrados.

Microsoft.perceptionSimulation.simulatedEyesCalibrationState.userCalibrationNeed

Os olhos precisam de ser calibrados.

Microsoft.PerceptionSimulation.SimulatedHandJointTrackingAccuracy

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

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

Microsoft.perceptionSimulation.simulatedHandJointTrackingAccuracy.Indisponível

O charro não está localizado.

Microsoft.perceptionSimulation.simulatedHandJointTrackingAccuracy.approximate

A posição conjunta é deduzida.

Microsoft.perceptionSimulation.simulatedHandJointTrackingAccuracy.Visible

A articulação está totalmente rastreada.

Microsoft.PerceptionSimulation.SimulatedHandPose

A precisão de rastreamento 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 estão configuradas para refletir uma pose fechada.

Microsoft.PerceptionSimulation.SimulatedHandPose.Open

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Point

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Pinch

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

Microsoft.PerceptionSimulation.SimulatedHandPose.Max

O valor máximo válido para SimulatedHandPose.

Microsoft.PerceptionSimulation.RebackState

Descreve o estado de uma reprodução.

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

Microsoft.perceptionSimulation.RebackState.stop

A gravação está atualmente parada e pronta para ser reproduzda.

Microsoft.perceptionSimulation.RebackState.Playing

A gravação está atualmente a ser gravada.

Microsoft.perceptionSimulation.RebackState.pausa

A gravação está atualmente em pausa.

Microsoft.PerceptionSimulation.RebackState.End

A gravação chegou ao fim.

Microsoft.PerceptionSimulation.Vetor3

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.vetor3.x

O componente X do vetor.

Microsoft.perceptionsimulation.vetor3.y

O componente Y do vetor.

Microsoft.perceptionSimulation.vetor3.z

O componente Z do vetor.

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

Construa um novo Vetor3.

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, em torno do eixo X.

Microsoft.PerceptionSimulation.Rotation3.Yaw

O componente de bocejo da rotação, mesmo em torno do eixo Y.

Microsoft.PerceptionSimulation.Rotation3.Roll

O componente roll da rotação, mesmo à volta do eixo Z.

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

Construa uma nova Rotação3.

Parâmetros

  • pitch - O componente de arremesso da Rotação.
  • bocejo - O componente de bocejo da Rotação.
  • rolo - O componente de rolo da rotação.

Microsoft.PerceptionSimulation.SimulatedHandJointConfiguration

Descreve a configuração de uma articulação numa 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 localização da articulação.

Microsoft.PerceptionSimulation.Frustum

Descreve uma vista frustum, como normalmente usada por uma câmara.

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

Microsoft.PerceptionSimulation.Frustum.Near

A distância mínima contida no frustum.

Microsoft.PerceptionSimulation.Frustum.Far

A distância máxima contida no frustum.

Microsoft.PerceptionSimulation.Frustum.FieldOfView

O campo de vista horizontal do frustum, em radiais (menos de PI).

Microsoft.PerceptionSimulation.Frustum.AspectRatio

A relação entre o campo de vista horizontal e o campo de vista vertical.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration

Descreve a configuração do visor do auricular 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 Ipd reportado pelo sistema para efeitos de renderização estéreo.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyEyeTransforms

Se os valores previstos para as transformações dos olhos esquerdo e direito devem ser considerados válidos e aplicados ao sistema de funcionamento.

Microsoft.PerceptionSimulation.SimulatedDisplayConfiguration.ApplyIpd

Se o valor previsto para o Ipd deve ser considerado válido e aplicado ao sistema de funcionamento.

Microsoft.PerceptionSimulation.iPerceptionsimulationManager

Raiz para gerar os pacotes utilizados para controlar um dispositivo.

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

Microsoft.perceptionSimulation.iPerceptionsimulationManager.device

Recupere o objeto do 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.reset.

Reinicia a simulação no seu estado padrão.

Microsoft.PerceptionSimulation.ISimulouDevice

Interface descrevendo 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.ISimulouDevice.HeadTracker

Recupere o localizador de cabeça do dispositivo simulado.

Microsoft.PerceptionSimulation.ISimuloudDevice.HandTracker

Recupere o rastreador de mão do dispositivo simulado.

Microsoft.PerceptionSimulation.ISimulatedDevice.SetSimuloudDeviceType (Microsoft.PerceptionSimulation.SimulatedDeviceType)

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

Parâmetros

  • tipo - O novo tipo de Dispositivo Simulado

Microsoft.PerceptionSimulation.ISimulouDevice2

Propriedades adicionais estão disponíveis através da função ISimulatedDevice a ISimulatedDevice2

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

};

Microsoft.PerceptionSimulation.ISimuloudDevice2.IsUserPresent

Recupere ou desemo ajuste se o humano simulado está ou não a usar ativamente os auscultadores.

Microsoft.PerceptionSimulation.ISimulouDevice2.DisplayConfiguration

Recupere ou deslome as propriedades do visor simulado.

Microsoft.perceptionSimulation.iSimutedHeadTracker

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

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

Microsoft.perceptionSimulation.iSimuloutedHeadTracker.HeadTrackerMode

Recupera e define o modo de rastreador de cabeça atual.

Microsoft.perceptionSimulation.iSimuloutedHandTracker

Interface descrevendo 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.iSimutedHandTracker.WorldPosition

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

Microsoft.perceptionSimulation.ISimutedHandTracker.position

Recupere e deslote a posição do localizador de mão simulado, em relação ao centro da cabeça.

Microsoft.perceptionSimulation.ISimutedHandTracker.pitch

Recupere e coloque o tom descendente do localizador de mão simulado.

Microsoft.PerceptionSimulation.ISimulatedHandTracker.FrustumIgnored

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

Microsoft.PerceptionSimulation.ISimutedHandTracker.Frustum

Recupere e defina as propriedades frustum utilizadas para determinar se as mãos são visíveis ao localizador de mão simulado.

Microsoft.PerceptionSimulation.ISimulatedHuman

Interface de alto nível 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.ISimutedHuman.WorldPosition

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

Microsoft.perceptionSimulation.ISimularHuman.direction

Recupere e desloe a direção dos rostos humanos simulados no mundo. 0 radians enfrenta o eixo Z negativo. Os radiais positivos giram no sentido horário sobre o eixo Y.

Microsoft.perceptionSimulation.ISimutedHuman.height

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

Microsoft.PerceptionSimulation.iSimutedHuman.leftHand

Recupere a mão esquerda do humano simulado.

Microsoft.PerceptionSimulation.ISimutedHuman.rightHand

Recupere a mão direita do humano simulado.

Microsoft.perceptionSimulation.iSimutedHuman.head

Recuperar a cabeça do humano simulado.

Microsoft.perceptionSimulation.iSimulatedHuman.move(microsoft.perceptionsimulation.vetor3)

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

Parâmetros

  • tradução - A tradução a mover,relativamente à posição atual.

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

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

Parâmetros

  • radians - A quantidade a rodar em torno do eixo Y.

Microsoft.PerceptionSimulation.ISimutedHuman2

Propriedades adicionais estão disponíveis através da fundição do ISimulado Humano para ISimuladoHuman2

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

Microsoft.PerceptionSimulation.ISimutedHuman2.leftController

Recupere o controlador 6-DOF esquerdo.

Microsoft.PerceptionSimulation.ISimutedHuman2.rightController

Recupere o controlador 6-DOF direito.

Microsoft.PerceptionSimulation.ISimulatedHand

Interface descrevendo 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.iSimutedHand.WorldPosition

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

Microsoft.perceptionSimulation.iSimuladoHand.position

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

Microsoft.perceptionSimulation.iSimulatedHand.ativado

Recupere e desacione se a mão está ativada atualmente.

Microsoft.perceptionSimulation.iSimuladoHand.Visible

Recupere se a mão está atualmente visível para o SimulatedDevice (isto é, se está em posição de ser detetado pelo HandTracker).

Microsoft.perceptionSimulation.iSimulatedHand.EnsureVisible

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

Microsoft.perceptionSimulation.iSimulatedHand.move(microsoft.perceptionsimulation.vetor3)

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

Parâmetros

  • tradução - A quantidade para traduzir a mão simulada.

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

Realizar um gesto com a mão simulada. Só será detetado pelo sistema se a mão estiver ativada.

Parâmetros

  • gesto - O gesto a realizar.

Microsoft.PerceptionSimulation.ISimulatedHand2

Propriedades adicionais estão disponíveis lançando um ISimuladoHand para ISimuladoHand2.

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

Microsoft.perceptionSimulation.iSimuladoHand2.orientation

Recupere ou deslome a rotação da mão simulada. Os radiais positivos giram no sentido dos ponteiros do relógio quando olham ao longo do eixo.

Microsoft.PerceptionSimulation.ISimulatedHand3

Propriedades adicionais estão disponíveis através do casting de um ISimuladoHand para ISimutedHand3

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.ISimutedHand3.GetJointConfiguration

Obtenha a configuração da articulação para a articulação especificada.

Microsoft.PerceptionSimulation.ISimutedHand3.SetJointConfiguration

Desa estar a configuração da articulação para a articulação especificada.

Microsoft.PerceptionSimulation.ISimultedHand3.SetHandPose

Coloque a mão numa pose conhecida com uma bandeira opcional para animar. Nota: a animação não resultará em articulações que reflitam imediatamente as suas configurações finais da articulação.

Microsoft.PerceptionSimulation.ISimuladoHead

Interface descrevendo 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.iSimutedHead.WorldPosition

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

Microsoft.perceptionSimulation.iSimutedHead.rotation

Recupere a rotação da cabeça simulada. Os radiais positivos giram no sentido dos ponteiros do relógio quando olham ao longo do eixo.

Microsoft.perceptionSimulation.ISimutedHead.diameter

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

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

Rode a cabeça simulada em relação à sua rotação atual. Os radiais positivos giram no sentido dos ponteiros do relógio quando olham ao longo do eixo.

Parâmetros

  • rotação - A quantidade a rodar.

Microsoft.PerceptionSimulation.ISimutedHead2

Propriedades adicionais estão disponíveis através do casting de um ISimuladoHead para ISimuladoHead2

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

Microsoft.perceptionSimulation.iSimutedHead2.eyes

Recupere os olhos do humano simulado.

Microsoft.perceptionSimulation.iSimulousixdofController

Interface descrevendo 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.iSimulousixdofController.WorldPosition

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

Microsoft.perceptionsimulation.isimulousixdofController.status

Recupere ou desateia o estado atual do controlador. O estado do controlador deve ser definido para um valor diferente de Off antes de qualquer chamada para mover, rodar ou apertar botões será bem sucedido.

Microsoft.perceptionSimulation.iSimulousixdofController.position

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

Microsoft.perceptionSimulation.iSimulousixdofController.orientation

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

Microsoft.perceptionsimulation.iSimulouddofController.move(microsoft.perceptionsimulation.vetor3)

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

Parâmetros

  • tradução - A quantidade para traduzir o controlador simulado.

Microsoft.perceptionsimulation.isimuloutedsixdofController.pressButton (simulatedsixdofControllerButton)

Pressione um botão no controlador simulado. Só será detetado pelo sistema se o controlador estiver ativado.

Parâmetros

  • botão - O botão para premir.

Microsoft.perceptionSimulation.isimuloutedsixdofController.releaseButton (simulatedsixdofControllerButton)

Liberte um botão no controlador simulado. Só será detetado pelo sistema se o controlador estiver ativado.

Parâmetros

  • botão - O botão a soltar.

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)

Desloque 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.iSimulousixdofController2

Propriedades e métodos adicionais estão disponíveis através da edição de um ISimutedSixDofController para ISimultedSixDofController2

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.ISimutedSixDofController2.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.ISimutedSixDofController2.SetThumbstickPosition (float, float)

Desloque 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.iSimulousixdofController2.batteryLevel

Recupere ou desloe o nível de bateria do controlador simulado. O valor deve ser superior a 0,0 e inferior ou igual a 100,0.

Microsoft.PerceptionSimulation.ISimulatedEyes

Interface descrevendo 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.iSimularEyes.Rotation

Recupere a rotação dos olhos simulados. Os radiais positivos giram no sentido dos ponteiros do relógio quando olham ao longo do eixo.

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

Rode os olhos simulados em relação à sua rotação atual. Os radiais positivos giram no sentido dos ponteiros do relógio quando olham ao longo do eixo.

Parâmetros

  • rotação - A quantidade a rodar.

Microsoft.perceptionSimulation.iSimulouedEyes.CalibrationState

Recupera ou define o estado de calibração dos olhos simulados.

Microsoft.perceptionSimulation.iSimulareyes.WorldPosition

Recupere a posição do nó em 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

Começa a reprodução. Se a gravação for interrompida, a reprodução será retomada a partir do local pausado; se parar, a reprodução começará no início. Se já está a jogar, esta chamada é ignorada.

Microsoft.perceptionSimulation.ISimulationRecording.pause

Pausa a reprodução na sua localização atual. Se a gravação for interrompida, a chamada é ignorada.

Microsoft.perceptionSimulation.iSimulationRecording.seek(system.uint64)

Procura a gravação para o tempo especificado (em intervalos de 100-nanosegundos desde o início) e faz uma pausa nesse local. Se o tempo for além do fim da gravação, é pausada no último quadro.

Parâmetros

  • carrapatos - O tempo para procurar.

Microsoft.perceptionSimulation.ISimulationRecording.stop

Para a reprodução e repõe 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.rebackStateChanged (Microsoft.perceptionSimulation.RebackState)

Chamado quando o estado de reprodução de um ISimulationRecording mudou.

Parâmetros

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

Microsoft.PerceptionSimulation.PerceptionSimulationManager

Objeto de raiz para criar objetos de Simulação de Perceçã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 no objeto para gerar pacotes simulados e entregá-los na pia fornecida.

Parâmetros

  • pia - A pia que receberá todos os pacotes gerados.

Valor devolvido

O gestor criado.

Microsoft.perceptionSimulation.PerceptionsimulationManager.createPerceptionsimulationRecording (system.string)

Crie uma pia, que armazena todos os pacotes recebidos num ficheiro no caminho especificado.

Parâmetros

  • caminho - O caminho do arquivo para criar.

Valor devolvido

A pia criada.

Microsoft.perceptionSimulation.perceptionsimulationManager.LoadPerceptionsimulationRecording (system.string,microsoft.perceptionsimulation.isimulationStreamsinkFactory)

Carregue uma gravação a partir do ficheiro especificado.

Parâmetros

  • caminho - O caminho do ficheiro para carregar.
  • fábrica - Uma fábrica utilizada pela gravação para a criação de um ISimulationStreamSink quando necessário.

Valor devolvido

A gravação carregada.

Microsoft.perceptionSimulation.PerceptionsimulationManager.LoadPerceptionsimulationRecording (system.string,microsoft.perceptionsimulation.isimulationStreamsinkFactory,Microsoft.perceptionsimulation.isimulationRecordingCallback)

Carregue uma gravação a partir do ficheiro especificado.

Parâmetros

  • caminho - O caminho do ficheiro para carregar.
  • fábrica - Uma fábrica utilizada pela gravação para a criação de um ISimulationStreamSink quando necessário.
  • callback - Uma chamada, que recebe atualizações que reclassigem o estado da gravação.

Valor devolvido

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.Nenhum

Um valor de 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 calibração do dispositivo. Os pacotes de calibração só são aceites por um sistema em 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 do ecrã do dispositivo.

Microsoft.PerceptionSimulation.StreamDataTypes.All

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

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(comprimento uint, byte[] pacote)

Recebe um único pacote, que é dactilografado internamente e 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 devolvido

A pia criada.