HoloLens (1º género) e Azure 302: Visão por computador


Nota

Os tutoriais da Mixed Reality Academy foram desenhados com HoloLens (1º género) e Auscultadores Imersivos de Realidade Mista em mente. Como tal, sentimos que é importante deixar estes tutoriais no lugar para os desenvolvedores que ainda estão à procura de orientação no desenvolvimento para esses dispositivos. Estes tutoriais não serão atualizados com os mais recentes instrumentos ou interações a serem utilizados para HoloLens 2. Serão mantidos para continuar a trabalhar nos dispositivos suportados. Haverá uma nova série de tutoriais que serão publicados no futuro que demonstrarão como se desenvolver para HoloLens 2. Este aviso será atualizado com um link para esses tutoriais quando forem publicados.


Neste curso, você aprenderá a reconhecer conteúdo visual dentro de uma imagem fornecida, usando as capacidades de Visão Computacional Azure numa aplicação de realidade mista.

Os resultados do reconhecimento serão apresentados como tags descritivas. Você pode usar este serviço sem precisar de treinar um modelo de machine learning. Se a sua implementação necessitar de formação de um modelo de aprendizagem automática, consulte MR e Azure 302b.

resultado do laboratório

O Microsoft Computer Vision é um conjunto de APIs projetado para fornecer aos desenvolvedores o processamento e análise de imagem (com informações de retorno), usando algoritmos avançados, todos da nuvem. Os desenvolvedores carregam um URL de imagem ou imagem, e os algoritmos da API da Microsoft Computer Vision analisam o conteúdo visual, com base nas entradas escolhidas pelo utilizador, que podem então devolver informações, incluindo, identificar o tipo e a qualidade de uma imagem, detetar rostos humanos (devolver as suas coordenadas) e marcar ou categorizar imagens. Para mais informações, visite a página Azure Computer Vision API.

Concluído este curso, terá uma aplicação de HoloLens de realidade mista, que poderá fazer o seguinte:

  1. Utilizando o gesto Tap, a câmara do HoloLens irá captar uma imagem.
  2. A imagem será enviada para o Serviço Azure Computer Vision API.
  3. Os objetos reconhecidos serão listados num simples grupo de UI posicionado na Cena da Unidade.

Na sua aplicação, cabe-lhe a si integrar os resultados com o seu design. Este curso destina-se a ensinar-lhe como integrar um Serviço Azure com o seu projeto Unidade. É seu trabalho usar o conhecimento que ganha com este curso para melhorar a sua aplicação de realidade mista.

Suporte de dispositivos

Curso HoloLens Auscultadores imersivos
MR e Azure 302: Visão por computador ✔️ ✔️

Nota

Embora este curso se centre principalmente em HoloLens, você também pode aplicar o que você aprende neste curso para Windows Mixed Reality auscultadores imersivos (VR). Como os auscultadores imersivos (VR) não têm câmaras acessíveis, vai precisar de uma câmara externa ligada ao seu PC. À medida que segue o curso, verá notas sobre quaisquer alterações que possa necessitar de utilizar para suportar auscultadores imersivos (VR).

Pré-requisitos

Nota

Este tutorial é projetado para desenvolvedores que têm experiência básica com Unidade e C#. Tenha também em atenção que os pré-requisitos e instruções escritas neste documento representam o que foi testado e verificado no momento da escrita (maio de 2018). Você é livre de usar o software mais recente, como listado dentro do artigo de instalação do artigo de ferramentas, embora não deva presumir-se que as informações neste curso irão perfeitamente corresponder ao que você vai encontrar em software mais recente do que o listado abaixo.

Recomendamos o seguinte hardware e software para este curso:

Antes de começar

  1. Para evitar encontrar problemas na construção deste projeto, sugere-se fortemente que crie o projeto mencionado neste tutorial numa pasta de raiz ou de raiz (os caminhos de pasta longa podem causar problemas no tempo de construção).
  2. Prepara e testa a tua HoloLens. Se precisar de apoio para configurar o seu HoloLens, visite o artigo de configuração HoloLens.
  3. É uma boa ideia executar a calibração e a sintonização sensor quando se começa a desenvolver uma nova App HoloLens (por vezes pode ajudar a executar essas tarefas para cada utilizador).

Para obter ajuda na Calibração, siga este link para o artigo de calibração HoloLens.

Para obter ajuda no Sensor Afinação, siga este link para o artigo de Afinação de Sensores HoloLens.

Capítulo 1 – O Portal Azure

Para utilizar o serviço API da Visão De Computador em Azure, terá de configurar uma instância do serviço a disponibilizar à sua aplicação.

  1. Primeiro, faça login no Portal Azure.

    Nota

    Se ainda não tiver uma conta Azure, terá de criar uma. Se estiver a seguir este tutorial numa sala de aula ou em laboratório, peça ao seu instrutor ou a um dos proctors para ajudar a criar a sua nova conta.

  2. Assim que iniciar sessão, clique em Novo no canto superior esquerdo e procure a API de Visão de Computador,e clique em Entrar.

    Criar um novo recurso em Azure

    Nota

    A palavra Novo pode ter sido substituída por Criar um recurso,em portais mais recentes.

  3. A nova página fornecerá uma descrição do serviço API da Visão Computacional. Na parte inferior esquerda desta página, selecione o botão Criar, para criar uma associação com este serviço.

    Sobre o serviço api de visão computacional

  4. Uma vez clicado no Criar:

    1. Insira o nome desejado para esta instância de serviço.

    2. Selecione uma subscrição.

    3. Selecione o Nível de Preços apropriado para si, se esta for a primeira vez que cria um Serviço API de Visão Por Computador, um nível gratuito (chamado F0) deverá estar disponível para si.

    4. Escolha um Grupo de Recursos ou crie um novo. Um grupo de recursos fornece uma forma de monitorizar, controlar o acesso, fornecer e gerir a faturação para uma recolha de ativos da Azure. Recomenda-se manter todos os serviços Azure associados a um único projeto (por exemplo, como estes laboratórios) sob um grupo de recursos comuns).

      Se desejar ler mais sobre os Grupos de Recursos Azure, visite o artigo do grupo de recursos.

    5. Determine a localização do seu grupo de recursos (se estiver a criar um novo Grupo de Recursos). A localização seria idealmente na região onde a aplicação iria decorrer. Alguns ativos da Azure só estão disponíveis em certas regiões.

    6. Também terá de confirmar que compreendeu os Termos e Condições aplicados a este Serviço.

    7. Clique em Criar.

      Informação de criação de serviços

  5. Uma vez clicado no Create,terá de esperar pela criação do serviço, pode demorar um minuto.

  6. Uma notificação aparecerá no portal assim que a instância de Serviço for criada.

    Consulte a nova notificação para o seu novo serviço

  7. Clique na notificação para explorar a sua nova instância de Serviço.

    Selecione o botão 'Ir para o recurso'.

  8. Clique no botão 'Ir ao recurso' na notificação para explorar a sua nova instância de Serviço. Você será levado para o seu novo caso de serviço API de visão de computador.

    A sua nova imagem de serviço de serviço API da Visão de Computador

  9. Dentro deste tutorial, a sua aplicação terá de estórias para o seu serviço, o que é feito através da utilização da Chave de Subscrição do seu serviço.

  10. A partir da página de arranque rápido, do seu serviço API de Visão de Computador, navegue até ao primeiro passo, agarre as suas teclase clique em Chaves (também pode fazê-lo clicando nas teclas de hiperligação azul, localizadas no menu de navegação de serviços, denotada pelo ícone chave). Isto revelará as chaves deserviço.

  11. Pegue uma cópia de uma das chaves apresentadas, pois vai precisar disso mais tarde no seu projeto.

  12. Volte para a página de início rápido, e a partir daí, pegue o seu ponto final. Esteja ciente de que o seu pode ser diferente, dependendo da sua região (que, se for, terá de alterar o seu código mais tarde). Pegue uma cópia deste ponto final para ser usado mais tarde:

    O seu novo serviço API com visão de computador

    Dica

    Pode verificar quais são os vários pontos finais AQUI.

Capítulo 2 - Criar o projeto Unidade

O seguinte é um conjunto típico para o desenvolvimento com realidade mista, e como tal, é um bom modelo para outros projetos.

  1. Abra a unidade e clique em Novo.

    Inicie o novo projeto de Unidade.

  2. Agora terá de fornecer um nome Project de unidade. Insira MR_ComputerVision. Certifique-se de que o tipo de projeto está definido para 3D. Desa esta medida para um local apropriado para si (lembre-se, mais perto dos diretórios de raiz é melhor). Em seguida, clique em Criar projeto.

    Forneça detalhes para o novo projeto de Unidade.

  3. Com a Unidade aberta, vale a pena verificar se o Script Editor padrão está definido para Visual Studio. Vá para Editar Preferências e, em seguida, a partir da nova janela, navegue para Ferramentas Externas. Alterar editor de script externo para Visual Studio 2017. Feche a janela Preferências.

    Atualizar a preferência do editor do script.

  4. Em seguida, vá ao File Build Definições e selecione Universal Windows Platform, em seguida, clique no botão 'Plataforma Switch' para aplicar a sua seleção.

    Construa Definições janela, mude a plataforma para UWP.

  5. Enquanto ainda está em File Build Definições e certifique-se de que:

    1. O dispositivo-alvo está definido para HoloLens

      Para os auscultadores imersivos, desaponte o dispositivo alvo a qualquer dispositivo.

    2. O Tipo de Construção está definido para D3D

    3. SDK está definido para as últimas instalações

    4. Visual Studio versão está definida para o mais recente instalado

    5. Build and Run está definido para máquina local

    6. Salve a cena e adicione-a à construção.

      1. Faça-o selecionando Add Open Scenes. Aparecerá uma janela de salvamento.

        Clique em adicionar botão de cenas abertas

      2. Crie uma nova pasta para isto e qualquer futuro, cena, em seguida, selecione o botão nova pasta, para criar uma nova pasta, nomeie-a Cenas.

        Criar uma pasta de scripts novos

      3. Abra a pasta Cenas recém-criada e, em seguida, no nome Ficheiro: campo de texto, escreva MR_ComputerVisionScene,clique em Guardar.

        Dê um nome à nova cena.

        Esteja atento, tem de guardar as suas cenas de Unidade dentro da pasta Ativos, uma vez que devem estar associadas à Unidade Project. Criar a pasta cenas (e outras pastas semelhantes) é uma forma típica de estruturar um projeto de Unidade.

    7. As definições restantes, em Build Definições,devem ser deixadas como padrão por enquanto.

  6. Na janela Build Definições, clique no botão Player Definições, isto abrirá o painel relacionado no espaço onde o Inspetor está localizado.

    Abra as definições do jogador.

  7. Neste painel, é necessário verificar algumas definições:

    1. No separador Other Definições:

      1. A versão de tempo de execução de scripts deve ser estável (.NET 3.5 Equivalente).

      2. Scripting Backend deve ser .NET

      3. O nível de compatibilidade da API deve ser .NET 4.6

        Atualize outras definições.

    2. No separador Definições de Publicação, em Capacidades,verifique:

      1. InternetClient

      2. Webcam

        Atualizar as definições de publicação.

    3. Mais abaixo no painel, em XR Definições (encontrado abaixo Definições De Publicação),marque o Suporte à Realidade Virtual, certifique-se de que o Windows Mixed Reality SDK é adicionado.

      Atualize o X R Definições.

  8. Back in Build DefiniçõesUnity C# Projects já não está acinzentado; marque a caixa de verificação ao lado desta.

  9. Feche a janela Build Definições.

  10. Guarde a sua Cena e Project(CENA DE SALVAMENTO DE FICHEIROS / > PROJETO DE SALVAMENTO DE FICHEIROS).

Capítulo 3 - Configuração da Câmara Principal

Importante

Se desejar saltar a componente De Unidade Configurar este curso, e continuar em linha reta em código, sinta-se livre para descarregar esta .unitypackage, importá-la para o seu projeto como pacote personalizado, e depois continuar a partir do Capítulo 5.

  1. No Painel Hierárquico,selecione a Câmara Principal.

  2. Uma vez selecionados, poderá ver todos os componentes da Câmara Principal no Painel de Inspetores.

    1. O objeto da câmara deve ser nomeado Câmara Principal (note a ortografia!)

    2. A Etiqueta principal da câmara deve ser definida para MainCamera (note a ortografia!)

    3. Certifique-se de que a Posição de Transformação está definida para 0,0,0

    4. Desasse as bandeiras para a cor sólida (ignore isto para auscultadores imersivos).

    5. Coloque a cor de fundo do componente da câmara em preto, Alpha 0 (Código Hex: #0000000) (ignore isto para auriculares imersivos).

      Atualizar componentes da câmara.

  3. Em seguida, terá de criar um simples objeto "Cursor" ligado à Câmara Principal, que o ajudará a posicionar a saída de análise de imagem quando a aplicação estiver em execução. Este Cursor determinará o ponto central do foco da câmara.

Para criar o Cursor:

  1. No Painel Hierárquico,clique à direita na Câmara Principal. Sob o Objeto 3D,clique na Esfera.

    Selecione o Objeto Cursor.

  2. Mude o nome da Esfera para Cursor (clique duas vezes no objeto Cursor ou prima o botão de teclado 'F2' com o objeto selecionado) e certifique-se de que está localizado como criança da Câmara Principal.

  3. No Painel Hierárquico,clique à esquerda no Cursor. Com o Cursor selecionado, ajuste as seguintes variáveis no Painel de Inspetor:

    1. Definir a Posição de Transformação para 0, 0, 5

    2. Coloque a balança em 0.02, 0.02, 0.02

      Atualize a posição e escala de transformação.

Capítulo 4 - Configuração do sistema de etiquetagem

Depois de ter capturado uma imagem com a câmara do HoloLens, essa imagem será enviada para a sua instância do Serviço API de Visão De Computador Azure para análise.

Os resultados dessa análise serão uma lista de objetos reconhecidos chamados Tags.

Utilizará etiquetas (como um texto 3D no espaço mundial) para exibir estas Tags no local onde a fotografia foi tirada.

Os seguintes passos mostrarão como configurar o objeto Label.

  1. Clique com o botão direito em qualquer lugar do Painel hierárquico (a localização não importa neste ponto), sob o Objeto 3D, adicione um texto 3D. Nomeie-o LabelText.

    Criar objeto de texto 3D.

  2. No Painel hierárquico,clique à esquerda no LabelText. Com o LabelText selecionado, ajuste as seguintes variáveis no Painel de Inspetores:

    1. Definir a Posição para 0,0,0
    2. Definir a Escala para 0.01, 0.01, 0.01
    3. No componente Malha de Texto:
    4. Substitua todo o texto dentro do Texto,por "..."
    5. Coloque a âncora no Centro Médio
    6. Definir o Alinhamento para o Centro
    7. Definir o tamanho do separador para 4
    8. Definir o tamanho da fonte para 50
    9. Desateia a cor para #FFFFFFFF

    Componente de texto

  3. Arraste o LabelText do Painel hierárquico,para a pasta de ativos,no interior do painel Project. Isto fará do LabelText um Prefab, para que possa ser instantâneo em código.

    Crie um pré-fabricado do objeto LabelText.

  4. Deverá eliminar o LabelText do Painel hierárquico,para que não seja exibido na cena de abertura. Como agora é um pré-fabricado, que irá recorrer para instâncias individuais da sua pasta Desemprego, não há necessidade de mantê-lo dentro do local.

  5. A estrutura final do objeto no Painel hierárquica deve ser igual à mostrada na imagem abaixo:

    Estrutura final do painel da hierarquia.

Capítulo 5 - Criar a classe ResultsLabel

O primeiro script que precisa de criar é a classe ResultsLabel, que é responsável pelo seguinte:

  • Criar os Rótulos no espaço mundial apropriado, em relação à posição da Câmara.
  • Exibindo as Tags da Anaysis de Imagem.

Para criar esta classe:

  1. Clique com o botão direito no painel de Projecte, em seguida, crie pasta. Nomeie as pastas Scripts.

    Crie a pasta scripts.

  2. Com a pasta Scripts criar, clique duas vezes para abrir. Em seguida, dentro dessa pasta, clique com o botão direito e selecione Criar então C# Script. Nomeie o script ResultsLabel.

  3. Clique duas vezes no novo script ResultsLabel para abri-lo com Visual Studio.

  4. Dentro da Classe insira o seguinte código na classe ResultsLabel:

        using System.Collections.Generic;
        using UnityEngine;
    
        public class ResultsLabel : MonoBehaviour
        {	
            public static ResultsLabel instance;
    
            public GameObject cursor;
    
            public Transform labelPrefab;
    
            [HideInInspector]
            public Transform lastLabelPlaced;
    
            [HideInInspector]
            public TextMesh lastLabelPlacedText;
    
            private void Awake()
            {
                // allows this instance to behave like a singleton
                instance = this;
            }
    
            /// <summary>
            /// Instantiate a Label in the appropriate location relative to the Main Camera.
            /// </summary>
            public void CreateLabel()
            {
                lastLabelPlaced = Instantiate(labelPrefab, cursor.transform.position, transform.rotation);
    
                lastLabelPlacedText = lastLabelPlaced.GetComponent<TextMesh>();
    
                // Change the text of the label to show that has been placed
                // The final text will be set at a later stage
                lastLabelPlacedText.text = "Analysing...";
            }
    
            /// <summary>
            /// Set the Tags as Text of the last Label created. 
            /// </summary>
            public void SetTagsToLastLabel(Dictionary<string, float> tagsDictionary)
            {
                lastLabelPlacedText = lastLabelPlaced.GetComponent<TextMesh>();
    
                // At this point we go through all the tags received and set them as text of the label
                lastLabelPlacedText.text = "I see: \n";
    
                foreach (KeyValuePair<string, float> tag in tagsDictionary)
                {
                    lastLabelPlacedText.text += tag.Key + ", Confidence: " + tag.Value.ToString("0.00 \n");
                }    
            }
        }
    
  5. Certifique-se de que guarda as suas alterações na Visual Studio antes de regressar à Unidade.

  6. De volta ao Editor de Unidade, clique e arraste a classe ResultsLabel da pasta Scripts para o objeto da Câmara Principal no Painel hierarquia.

  7. Clique na Câmara Principal e veja o Painel do Inspetor.

Notará que a partir do script que acabou de arrastar para a Câmara, existem dois campos: Cursor e Label Prefab.

  1. Arraste o objeto chamado Cursor do Painel hierárquica para a ranhura chamada Cursor,como mostra a imagem abaixo.

  2. Arraste o objeto denominado LabelText da Pasta de Ativos no Painel Project para a ranhura denominada Label Prefab, como mostra a imagem abaixo.

    Estabeleça os alvos de referência dentro da Unidade.

Capítulo 6 - Criar a classe ImageCapture

A próxima aula que vai criar é a aula ImageCapture. Esta classe é responsável por:

  • Capturar uma imagem utilizando a Câmara HoloLens e guardá-la na Pasta da Aplicação.
  • Captação de gestos de toque do utilizador.

Para criar esta classe:

  1. Vá à pasta Scripts que criou anteriormente.

  2. Clique com o botão direito dentro da pasta, Crie O Script C#. Ligue para o script ImageCapture.

  3. Clique duas vezes no novo script ImageCapture para abri-lo com Visual Studio.

  4. Adicione os seguintes espaços de nome ao topo do ficheiro:

        using System.IO;
        using System.Linq;
        using UnityEngine;
        using UnityEngine.XR.WSA.Input;
        using UnityEngine.XR.WSA.WebCam;
    
  5. Em seguida, adicione as seguintes variáveis dentro da classe ImageCapture, acima do método Iniciar():

        public static ImageCapture instance; 
        public int tapsCount;
        private PhotoCapture photoCaptureObject = null;
        private GestureRecognizer recognizer;
        private bool currentlyCapturing = false;
    

A variável tapsCount irá armazenar o número de gestos de toque capturados pelo utilizador. Este número é usado no nome das imagens capturadas.

  1. O código para métodos de despertar e arranque() agora precisa ser adicionado. Estes serão chamados quando a classe rubricar:

        private void Awake()
        {
            // Allows this instance to behave like a singleton
            instance = this;
        }
    
        void Start()
        {
            // subscribing to the HoloLens API gesture recognizer to track user gestures
            recognizer = new GestureRecognizer();
            recognizer.SetRecognizableGestures(GestureSettings.Tap);
            recognizer.Tapped += TapHandler;
            recognizer.StartCapturingGestures();
        }
    
  2. Implemente um manipulador que será chamado quando ocorrer um gesto tap.

        /// <summary>
        /// Respond to Tap Input.
        /// </summary>
        private void TapHandler(TappedEventArgs obj)
        {
            // Only allow capturing, if not currently processing a request.
            if(currentlyCapturing == false)
            {
                currentlyCapturing = true;
    
                // increment taps count, used to name images when saving
                tapsCount++;
    
                // Create a label in world space using the ResultsLabel class
                ResultsLabel.instance.CreateLabel();
    
                // Begins the image capture and analysis procedure
                ExecuteImageCaptureAndAnalysis();
            }
        }
    

O método TapHandler incrementa o número de torneiras capturadas do utilizador e utiliza a posição atual do Cursor para determinar onde posicionar uma nova Etiqueta.

Este método chama então o método ExecuteImageCaptureAndAnalysis() para iniciar a funcionalidade principal desta aplicação.

  1. Uma vez capturada e armazenada uma Imagem, serão chamados os seguintes manipuladores. Se o processo for bem sucedido, o resultado é passado para o VisionManager (que ainda está por criar) para análise.

        /// <summary>
        /// Register the full execution of the Photo Capture. If successful, it will begin 
        /// the Image Analysis process.
        /// </summary>
        void OnCapturedPhotoToDisk(PhotoCapture.PhotoCaptureResult result)
        {
            // Call StopPhotoMode once the image has successfully captured
            photoCaptureObject.StopPhotoModeAsync(OnStoppedPhotoMode);
        }
    
        void OnStoppedPhotoMode(PhotoCapture.PhotoCaptureResult result)
        {
            // Dispose from the object in memory and request the image analysis 
            // to the VisionManager class
            photoCaptureObject.Dispose();
            photoCaptureObject = null;
            StartCoroutine(VisionManager.instance.AnalyseLastImageCaptured()); 
        }
    
  2. Em seguida, adicione o método que a aplicação utiliza para iniciar o processo de captura de imagem e armazenar a imagem.

        /// <summary>    
        /// Begin process of Image Capturing and send To Azure     
        /// Computer Vision service.   
        /// </summary>    
        private void ExecuteImageCaptureAndAnalysis()  
        {    
            // Set the camera resolution to be the highest possible    
            Resolution cameraResolution = PhotoCapture.SupportedResolutions.OrderByDescending((res) => res.width * res.height).First();    
    
            Texture2D targetTexture = new Texture2D(cameraResolution.width, cameraResolution.height);
    
            // Begin capture process, set the image format    
            PhotoCapture.CreateAsync(false, delegate (PhotoCapture captureObject)    
            {    
                photoCaptureObject = captureObject;    
                CameraParameters camParameters = new CameraParameters();    
                camParameters.hologramOpacity = 0.0f;    
                camParameters.cameraResolutionWidth = targetTexture.width;    
                camParameters.cameraResolutionHeight = targetTexture.height;    
                camParameters.pixelFormat = CapturePixelFormat.BGRA32;
    
                // Capture the image from the camera and save it in the App internal folder    
                captureObject.StartPhotoModeAsync(camParameters, delegate (PhotoCapture.PhotoCaptureResult result)
                {    
                    string filename = string.Format(@"CapturedImage{0}.jpg", tapsCount);
    
                    string filePath = Path.Combine(Application.persistentDataPath, filename);
    
                    VisionManager.instance.imagePath = filePath;
    
                    photoCaptureObject.TakePhotoAsync(filePath, PhotoCaptureFileOutputFormat.JPG, OnCapturedPhotoToDisk);
    
                    currentlyCapturing = false;
                });   
            });    
        }
    

Aviso

Neste momento, irá notar um erro que aparece no Painel de Consolasdo Editor de Unidade . Isto porque o código faz referência à classe VisionManager que irá criar no próximo Capítulo.

Capítulo 7 - Chamada para Azure e Análise de Imagem

O último guião que precisas de criar é a aula VisionManager.

Esta classe é responsável por:

  • Carregando a última imagem capturada como uma variedade de bytes.
  • Envio do conjunto byte para a sua instância do Serviço API de Visão De Computador Azure para análise.
  • Recebendo a resposta como uma corda JSON.
  • Deserializar a resposta e passar as Tags resultantes para a classe ResultsLabel.

Para criar esta classe:

  1. Clique duas vezes na pasta Scripts para abri-la.

  2. Clique com o botão direito dentro da pasta Scripts, clique em Criar Script C#. Nomeie o script VisionManager.

  3. Clique duas vezes no novo script para abri-lo com Visual Studio.

  4. Atualize os espaços de nome para serem os mesmos que os seguintes, no topo da classe VisionManager:

        using System;
        using System.Collections;
        using System.Collections.Generic;
        using System.IO;
        using UnityEngine;
        using UnityEngine.Networking;
    
  5. No topo do seu script, dentro da classe VisionManager (acima do método Start),agora precisa de criar duas Classes que representarão a resposta deserizada JSON do Azure:

        [System.Serializable]
        public class TagData
        {
            public string name;
            public float confidence;
        }
    
        [System.Serializable]
        public class AnalysedObject
        {
            public TagData[] tags;
            public string requestId;
            public object metadata;
        }
    

    Nota

    As classes TagData e AnalysedObject precisam de ter o atributo [System.Serializable] adicionado antes da declaração para poder ser deseralizado com as bibliotecas da Unidade.

  6. Na classe VisionManager, deve adicionar as seguintes variáveis:

        public static VisionManager instance;
    
        // you must insert your service key here!    
        private string authorizationKey = "- Insert your key here -";    
        private const string ocpApimSubscriptionKeyHeader = "Ocp-Apim-Subscription-Key";
        private string visionAnalysisEndpoint = "https://westus.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags";   // This is where you need to update your endpoint, if you set your location to something other than west-us.
    
        internal byte[] imageBytes;
    
        internal string imagePath;
    

    Aviso

    Certifique-se de que insere a sua Chave Auth na variável de autorizaçãoKey. Terá anotado a sua Chave Auth no início deste curso, Capítulo 1.

    Aviso

    A variável visionAnalysisEndpoint pode diferir da especificada neste exemplo. O oeste-nos refere-se estritamente a instâncias de serviço criadas para a região oeste dos EUA. Atualize-o com o seu URL de ponto final; aqui estão alguns exemplos de como pode parecer:

    • Europa Ocidental: https://westeurope.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags
    • Sudeste Asiático: https://southeastasia.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags
    • Austrália Leste: https://australiaeast.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags
  7. O código para despertar agora precisa ser adicionado.

        private void Awake()
        {
            // allows this instance to behave like a singleton
            instance = this;
        }
    
  8. Em seguida, adicione a coroutina (com o método de fluxo estático abaixo), que obterá os resultados da análise da imagem capturada pela Classe ImageCapture.

        /// <summary>
        /// Call the Computer Vision Service to submit the image.
        /// </summary>
        public IEnumerator AnalyseLastImageCaptured()
        {
            WWWForm webForm = new WWWForm();
            using (UnityWebRequest unityWebRequest = UnityWebRequest.Post(visionAnalysisEndpoint, webForm))
            {
                // gets a byte array out of the saved image
                imageBytes = GetImageAsByteArray(imagePath);
                unityWebRequest.SetRequestHeader("Content-Type", "application/octet-stream");
                unityWebRequest.SetRequestHeader(ocpApimSubscriptionKeyHeader, authorizationKey);
    
                // the download handler will help receiving the analysis from Azure
                unityWebRequest.downloadHandler = new DownloadHandlerBuffer();
    
                // the upload handler will help uploading the byte array with the request
                unityWebRequest.uploadHandler = new UploadHandlerRaw(imageBytes);
                unityWebRequest.uploadHandler.contentType = "application/octet-stream";
    
                yield return unityWebRequest.SendWebRequest();
    
                long responseCode = unityWebRequest.responseCode;     
    
                try
                {
                    string jsonResponse = null;
                    jsonResponse = unityWebRequest.downloadHandler.text;
    
                    // The response will be in Json format
                    // therefore it needs to be deserialized into the classes AnalysedObject and TagData
                    AnalysedObject analysedObject = new AnalysedObject();
                    analysedObject = JsonUtility.FromJson<AnalysedObject>(jsonResponse);
    
                    if (analysedObject.tags == null)
                    {
                        Debug.Log("analysedObject.tagData is null");
                    }
                    else
                    {
                        Dictionary<string, float> tagsDictionary = new Dictionary<string, float>();
    
                        foreach (TagData td in analysedObject.tags)
                        {
                            TagData tag = td as TagData;
                            tagsDictionary.Add(tag.name, tag.confidence);                            
                        }
    
                        ResultsLabel.instance.SetTagsToLastLabel(tagsDictionary);
                    }
                }
                catch (Exception exception)
                {
                    Debug.Log("Json exception.Message: " + exception.Message);
                }
    
                yield return null;
            }
        }
    
        /// <summary>
        /// Returns the contents of the specified file as a byte array.
        /// </summary>
        private static byte[] GetImageAsByteArray(string imageFilePath)
        {
            FileStream fileStream = new FileStream(imageFilePath, FileMode.Open, FileAccess.Read);
            BinaryReader binaryReader = new BinaryReader(fileStream);
            return binaryReader.ReadBytes((int)fileStream.Length);
        }  
    
  9. Certifique-se de que guarda as suas alterações na Visual Studio antes de regressar à Unidade.

  10. De volta ao Editor de Unidade, clique e arraste as aulas VisionManager e ImageCapture da pasta Scripts para o objeto da Câmara Principal no Painel hierarquia.

Capítulo 8 - Antes de construir

Para realizar um teste minucioso da sua aplicação, terá de a carregar lateralmente no seu HoloLens. Antes de o fazer, certifique-se de que:

  • Todas as definições mencionadas no capítulo 2 estão corretamente definidas.
  • Todos os scripts estão ligados ao objeto da Câmara Principal.
  • Todos os campos do Painel De Inspetor de Câmara Principal são atribuídos corretamente.
  • Certifique-se de que insere a sua Chave Auth na variável de autorizaçãoKey.
  • Certifique-se de que também verificou o seu ponto final no seu script VisionManager e que se alinha com a sua região (este documento utiliza-nos por defeito).

Capítulo 9 - Construir a Solução UWP e sidecar a aplicação

Tudo o que é necessário para a secção de Unidade deste projeto já está concluído, pelo que é tempo de o construir a partir da Unidade.

  1. Navegue para construir Definiçõesde arquivos Definições...

  2. A partir da janela Build Definições, clique em Construir.

    Construindo a app da Unidade

  3. Se já não for, marque projetos de Unidade C#.

  4. Clique em Construir. A Unidade lançará uma janela do Explorador de Ficheiros, onde precisa de criar e, em seguida, selecionará uma pasta para construir a aplicação. Crie esta pasta agora, e nomeie-a App. Em seguida, com a pasta app selecionada, prima Select Folder.

  5. A unidade começará a construir o seu projeto para a pasta app.

  6. Uma vez terminada a construção da Unidade (pode demorar algum tempo), abrirá uma janela do Explorador de Ficheiros no local da sua construção (verifique a sua barra de tarefas, uma vez que pode nem sempre aparecer acima das suas janelas, mas irá notificá-lo da adição de uma nova janela).

Capítulo 10 - Implantação para HoloLens

Para implantar no HoloLens:

  1. Necessitará do endereço IP do seu HoloLens (para implementação remota) e para garantir que o seu HoloLens está no Modo de Desenvolvimento. Para efetuar este procedimento:

    1. Enquanto usa o HoloLens, abra a Definições.
    2. Ir para a Rede Internet Wi-Fi >> Opções Avançadas
    3. Note o endereço IPv4.
    4. Em seguida, volte a Definições, e depois atualizar segurança para desenvolvedores
    5. Definir modo de desenvolvedor ligado.
  2. Navegue para a sua nova build Unity (a pasta App) e abra o ficheiro de solução com Visual Studio.

  3. Na Configuração da Solução selecione Debug.

  4. Na Plataforma solução, selecione x86,Máquina Remota.

    Implemente a solução a partir de Visual Studio.

  5. Vá ao menu Construir e clique na Solução De Implementação,para carregar a aplicação para o seu HoloLens.

  6. A sua App deve agora figurar na lista de aplicações instaladas no seu HoloLens, prontas a serem lançadas!

Nota

Para implementar para auscultadores imersivos, desloque a Plataforma de Solução para Máquina Local,e coloque a Configuração em Debug,com x86 como Plataforma. Em seguida, desloque-se para a máquina local, utilizando o menu Construir,selecionando a Solução de Implantação.

A sua aplicação API de visão de computador acabada

Parabéns, você construiu uma aplicação de realidade mista que aproveita a AZure Computer Vision API para reconhecer objetos do mundo real, e mostrar confiança do que foi visto.

resultado do laboratório

Exercícios de bónus

Exercício 1

Tal como utilizou o parâmetro Tags (como evidenciado no ponto final utilizado no VisionManager),alargar a aplicação para detetar outras informações; ver quais os outros parâmetros a que tem acesso AQUI.

Exercício 2

Exiba os dados do Azure devolvidos, de uma forma mais conversadora e legível, talvez escondendo os números. Como se um bot estivesse a falar com o utilizador.