HoloLens (1.ª geração) e Azure 302: Visão computacional
Nota
Os tutoriais da Academia de Realidade Mista foram projetados com HoloLens (1ª geração) e Headsets Imersivos de Realidade Mista em mente. Como tal, sentimos que é importante deixar estes tutoriais no lugar para desenvolvedores que ainda estão procurando orientação no desenvolvimento para esses dispositivos. Esses tutoriais não serão atualizados com os conjuntos de ferramentas ou interações mais recentes que estão sendo usados para o HoloLens 2. Eles serão mantidos para continuar trabalhando nos dispositivos suportados. Haverá uma nova série de tutoriais que serão publicados no futuro que demonstrarão como desenvolver para o HoloLens 2. Este aviso será atualizado com um link para esses tutoriais quando eles forem publicados.
Neste curso, você aprenderá a reconhecer conteúdo visual em uma imagem fornecida, usando os recursos do Azure Computer Vision em um aplicativo de realidade mista.
Os resultados do reconhecimento serão exibidos como tags descritivas. Você pode usar esse serviço sem precisar treinar um modelo de aprendizado de máquina. Se sua implementação exigir treinamento de um modelo de aprendizado de máquina, consulte MR e Azure 302b.
O Microsoft Computer Vision é um conjunto de APIs projetado para fornecer aos desenvolvedores processamento e análise de imagens (com informações de retorno), usando algoritmos avançados, tudo a partir da nuvem. Os desenvolvedores carregam uma imagem ou URL de imagem, e os algoritmos da API do Microsoft Computer Vision analisam o conteúdo visual, com base nas entradas escolhidas pelo usuário, que pode retornar informações, incluindo, identificando o tipo e a qualidade de uma imagem, detetar rostos humanos (retornando suas coordenadas) e marcando ou categorizando imagens. Para obter mais informações, visite a página da API do Azure Computer Vision.
Tendo concluído este curso, você terá um aplicativo HoloLens de realidade mista, que será capaz de fazer o seguinte:
- Usando o gesto Toque, a câmera do HoloLens capturará uma imagem.
- A imagem será enviada para o Serviço de API do Azure Computer Vision.
- Os objetos reconhecidos serão listados em um grupo de interface do usuário simples posicionado na cena Unity.
Na sua aplicação, cabe-lhe a si decidir como irá integrar os resultados com o seu design. Este curso foi criado para ensiná-lo a integrar um Serviço do Azure ao seu projeto Unity. É seu trabalho usar o conhecimento que você ganha com este curso para melhorar sua aplicação de realidade mista.
Suporte de dispositivos
| Curso | HoloLens | Auriculares imersivos |
|---|---|---|
| MR e Azure 302: Visão computacional | ✔️ | ✔️ |
Nota
Embora este curso se concentre principalmente no HoloLens, você também pode aplicar o que aprendeu neste curso aos fones de ouvido imersivos (VR) do Windows Mixed Reality. Como os fones de ouvido imersivos (VR) não têm câmeras acessíveis, você precisará de uma câmera externa conectada ao seu PC. Ao acompanhar o curso, você verá anotações sobre quaisquer alterações que talvez precise empregar para suportar fones de ouvido imersivos (VR).
Pré-requisitos
Nota
Este tutorial foi projetado para desenvolvedores que têm experiência básica com Unity e C#. Por favor, esteja ciente de que os pré-requisitos e instruções escritas neste documento representam o que foi testado e verificado no momento da redação (maio de 2018). Você é livre para usar o software mais recente, conforme listado no artigo instalar as ferramentas , embora não se deva presumir que as informações neste curso corresponderão perfeitamente ao que você encontrará em software mais recente do que o listado abaixo.
Recomendamos o seguinte hardware e software para este curso:
- Um PC de desenvolvimento, compatível com Windows Mixed Reality para desenvolvimento imersivo (VR) de auriculares
- Windows 10 Fall Creators Update (ou posterior) com o modo de desenvolvedor ativado
- O SDK mais recente do Windows 10
- Unidade 2017.4
- Visual Studio 2017
- Um auricular imersivo (VR) Windows Mixed Reality ou Microsoft HoloLens com o modo de programador ativado
- Uma câmara ligada ao seu PC (para desenvolvimento de auriculares imersivos)
- Acesso à Internet para configuração do Azure e recuperação da API de Visão Computacional
Antes de começar
- Para evitar encontrar problemas ao criar este projeto, é altamente recomendável que você crie o projeto mencionado neste tutorial em uma pasta raiz ou quase raiz (caminhos de pasta longos podem causar problemas em tempo de compilação).
- Configure e teste o seu HoloLens. Se você precisar de suporte para configurar seu HoloLens, visite o artigo de configuração do HoloLens.
- É uma boa ideia executar a calibração e o ajuste do sensor ao começar a desenvolver um novo aplicativo HoloLens (às vezes, pode ajudar a executar essas tarefas para cada usuário).
Para obter ajuda sobre calibração, siga este link para o artigo Calibração HoloLens.
Para obter ajuda sobre o ajuste do sensor, siga este link para o artigo HoloLens Sensor Tuning.
Capítulo 1 – O Portal do Azure
Para usar o serviço de API de Visão Computacional no Azure, você precisará configurar uma instância do serviço a ser disponibilizada para seu aplicativo.
Primeiro, faça logon no Portal do Azure.
Nota
Se ainda não tiver uma conta do Azure, terá de criar uma. Se você estiver seguindo este tutorial em uma situação de sala de aula ou laboratório, peça ajuda ao seu instrutor ou a um dos proctors para configurar sua nova conta.
Depois de fazer login, clique em Novo no canto superior esquerdo, procure por Computer Vision API e clique em Enter.
Nota
A palavra Novo pode ter sido substituída por Criar um recurso, em portais mais recentes.
A nova página fornecerá uma descrição do serviço Computer Vision API . No canto inferior esquerdo desta página, selecione o botão Criar para criar uma associação com este serviço.
Depois de clicar em Criar:
Insira o Nome desejado para esta instância de serviço.
Selecione uma Subscrição.
Selecione o Nível de Preço apropriado para você, se esta for a primeira vez que cria um Serviço de API de Visão Computacional, um nível gratuito (chamado F0) deve estar disponível para você.
Escolha um Grupo de Recursos ou crie um novo. Um grupo de recursos fornece uma maneira de monitorar, controlar o acesso, provisionar e gerenciar a cobrança de uma coleção de ativos do Azure. É recomendável manter todos os serviços do Azure associados a um único projeto (por exemplo, como esses laboratórios) em um grupo de recursos comum).
Se desejar ler mais sobre os Grupos de Recursos do Azure, visite o artigo do grupo de recursos.
Determine a Localização do seu grupo de recursos (se estiver a criar um novo Grupo de Recursos). O ideal seria que o local fosse na região onde o aplicativo seria executado. Alguns ativos do Azure só estão disponíveis em determinadas regiões.
Você também precisará confirmar que compreendeu os Termos e Condições aplicados a este Serviço.
Clique em Criar.
Depois de clicar em Criar, você terá que esperar que o serviço seja criado, isso pode levar um minuto.
Uma notificação aparecerá no portal assim que a instância de serviço for criada.
Clique na notificação para explorar sua nova instância de serviço.
Clique no botão Ir para recurso na notificação para explorar sua nova instância de serviço. Você será levado para sua nova instância de serviço da API de Visão Computacional.
Dentro deste tutorial, seu aplicativo precisará fazer chamadas para o seu serviço, o que é feito usando a Chave de Assinatura do seu serviço.
Na página Início rápido, do seu serviço de API de Visão Computacional, navegue até a primeira etapa, Pegue suas chaves, e clique em Chaves (você também pode conseguir isso clicando no hiperlink azul Chaves, localizado no menu de navegação de serviços, indicado pelo ícone de chave). Isso revelará suas chaves de serviço.
Tire uma cópia de uma das chaves exibidas, pois você precisará disso mais tarde em seu projeto.
Volte para a página de início rápido e, a partir daí, busque seu ponto de extremidade. Esteja ciente de que o seu pode ser diferente, dependendo da sua região (que, se for, você precisará fazer uma alteração no seu código mais tarde). Tire uma cópia deste ponto de extremidade para uso posterior:
Gorjeta
Você pode verificar quais são os vários endpoints AQUI.
Capítulo 2 – Configurar o projeto Unity
O seguinte é uma configuração típica para desenvolver com realidade mista e, como tal, é um bom modelo para outros projetos.
Abra o Unity e clique em Novo.
Agora você precisará fornecer um nome de Projeto Unity. Inserir MR_ComputerVision. Verifique se o tipo de projeto está definido como 3D. Defina o Local para algum lugar apropriado para você (lembre-se, mais perto de diretórios raiz é melhor). Em seguida, clique em Criar projeto.
Com o Unity aberto, vale a pena verificar se o Editor de Scripts padrão está definido como Visual Studio. Vá para Editar > Preferências e, na nova janela, navegue até Ferramentas Externas. Altere o Editor de Scripts Externo para Visual Studio 2017. Feche a janela Preferências .
Em seguida, vá para Configurações de compilação de arquivo > e selecione Plataforma Universal do Windows e, em seguida, clique no botão Alternar plataforma para aplicar sua seleção.
Enquanto ainda estiver em Configurações de compilação de arquivo > e certifique-se de que:
O dispositivo alvo está definido como HoloLens
Para os auriculares imersivos, defina Target Device como Any Device.
O tipo de compilação está definido como D3D
O SDK está definido como Instalado mais recente
Versão do Visual Studio está definida como A versão mais recente instalada
Build and Run está definido como Máquina Local
Salve a cena e adicione-a à compilação.
Faça isso selecionando Adicionar cenas abertas. Será exibida uma janela de salvamento.
Crie uma nova pasta para esta e qualquer cena futura e, em seguida, selecione o botão Nova pasta , para criar uma nova pasta, nomeie-a Cenas.
Abra a pasta Cenas recém-criada e, no campo de texto Nome do arquivo:, digite MR_ComputerVisionScene e clique em Salvar.
Esteja ciente, você deve salvar suas cenas Unity dentro da pasta Ativos , pois elas devem estar associadas ao Projeto Unity. Criar a pasta scenes (e outras pastas semelhantes) é uma maneira típica de estruturar um projeto Unity.
As configurações restantes, em Configurações de compilação, devem ser deixadas como padrão por enquanto.
Na janela Configurações de compilação, clique no botão Configurações do player, isso abrirá o painel relacionado no espaço onde o inspetor está localizado.
Neste painel, algumas configurações precisam ser verificadas:
Na guia Outras configurações:
A versão do Scripting Runtime deve ser estável (equivalente ao .NET 3.5).
O back-end de scripts deve ser .NET
O nível de compatibilidade da API deve ser .NET 4.6
Na guia Configurações de publicação , em Recursos, verifique:
InternetClient
Webcam
Mais abaixo no painel, em Configurações XR (encontradas abaixo de Configurações de publicação), marque Realidade Virtual suportada, verifique se o SDK de realidade mista do Windows foi adicionado.
De volta às configurações de compilação, o Unity C# Projects não está mais acinzentado, marque a caixa de seleção ao lado disso.
Feche a janela Configurações de compilação.
Salve sua cena e projeto (FILE > SAVE SCENE / FILE > SAVE PROJECT).
Capítulo 3 – Configuração da câmara principal
Importante
Se você deseja pular o componente Unity set deste curso e continuar direto no código, sinta-se à vontade para baixar este .unitypackage, importá-lo para seu projeto como um pacote personalizado e, em seguida, continuar a partir do Capítulo 5.
No Painel Hierarquia, selecione a Câmara Principal.
Uma vez selecionado, você será capaz de ver todos os componentes da câmera principal no painel do inspetor.
O objeto Camera deve ser chamado Main Camera (observe a ortografia!)
A tag da câmera principal deve ser definida como MainCamera (observe a ortografia!)
Verifique se a Posição de transformação está definida como 0, 0, 0
Defina Clear Flags como Solid Color (ignore isso para fones de ouvido imersivos).
Defina a cor de fundo do componente da câmera como preto, Alpha 0 (código hexadecimal: #00000000) (ignore isso para fone de ouvido imersivo).
Em seguida, você terá que criar um objeto "Cursor" simples anexado à câmera principal, que irá ajudá-lo a posicionar a saída de análise de imagem quando o aplicativo está em execução. Este cursor irá determinar o ponto central do foco da câmara.
Para criar o cursor:
No Painel Hierarquia, clique com o botão direito do rato na Câmara Principal. Em Objeto 3D, clique em Sphere.
Renomeie a esfera para cursor (clique duas vezes no objeto Cursor ou pressione o botão do teclado 'F2' com o objeto selecionado) e certifique-se de que ele está localizado como filho da câmera principal.
No Painel Hierarquia, clique com o botão esquerdo no Cursor. Com o cursor selecionado, ajuste as seguintes variáveis no Painel do inspetor:
Defina a posição de transformação como 0, 0, 5
Defina a escala como 0,02, 0,02, 0,02
Capítulo 4 – Configurar o sistema de etiquetas
Depois de capturar uma imagem com a câmera do HoloLens, essa imagem será enviada para sua instância do Serviço de API de Visão Computacional do Azure para análise.
Os resultados dessa análise serão uma lista de objetos reconhecidos chamada Tags.
Você usará Etiquetas (como um texto 3D no espaço mundial) para exibir essas Tags no local em que a foto foi tirada.
As etapas a seguir mostrarão como configurar o objeto Label .
Clique com o botão direito do mouse em qualquer lugar no Painel de Hierarquia (o local não importa neste momento), em Objeto 3D, adicione um Texto 3D. Nomeie-o LabelText.
No Painel Hierarquia, clique com o botão esquerdo no LabelText. Com o LabelText selecionado, ajuste as seguintes variáveis no Painel do Inspetor:
- Defina a posição como 0,0,0
- Defina a escala como 0,01, 0,01, 0,01
- No componente Malha de texto:
- Substitua todo o texto em Texto por "..."
- Definir a âncora para o centro do meio
- Definir o alinhamento para o centro
- Defina o tamanho da guia como 4
- Defina o tamanho da fonte como 50
- Defina a cor como #FFFFFFFF
Arraste o LabelText do Painel Hierarquia para a Pasta de Ativos, dentro do Painel do Projeto. Isso tornará o LabelText um pré-fabricado, para que possa ser instanciado no código.
Você deve excluir o LabelText do Painel Hierarquia, para que ele não seja exibido na cena de abertura. Como agora é um pré-fabricado, que você chamará para instâncias individuais da sua pasta Ativos, não há necessidade de mantê-lo dentro da cena.
A estrutura final do objeto no Painel de Hierarquia deve ser como a mostrada na imagem abaixo:
Capítulo 5 – Criar a classe ResultsLabel
O primeiro script que você precisa criar é a classe ResultsLabel , que é responsável pelo seguinte:
- Criação das etiquetas no espaço do mundo apropriado, em relação à posição da câmara.
- Exibindo as tags da análise de imagem.
Para criar esta classe:
Clique com o botão direito do rato no Painel do Projeto e, em seguida, em Criar > Pasta. Nomeie a pasta Scripts.
Com a pasta Scripts create, clique duas vezes nela para abrir. Em seguida, dentro dessa pasta, clique com o botão direito do mouse e selecione Criar > e depois Script C#. Nomeie o script ResultsLabel.
Clique duas vezes no novo script ResultsLabel para abri-lo com o Visual Studio.
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"); } } }Certifique-se de salvar suas alterações no Visual Studio antes de retornar ao Unity.
De volta ao Editor Unity, clique e arraste a classe ResultsLabel da pasta Scripts para o objeto Main Camera no Painel Hierarchy.
Clique na câmera principal e olhe para o painel do inspetor.
Você notará que, a partir do script que você acabou de arrastar para a câmera, há dois campos: Cursor e Rótulo pré-fabricado.
Arraste o objeto chamado Cursor do Painel de Hierarquia para o slot chamado Cursor, conforme mostrado na imagem abaixo.
Arraste o objeto chamado LabelText da pasta Assets no painel Project para o slot chamado Label Prefab, conforme mostrado na imagem abaixo.
Capítulo 6 – Criar a classe ImageCapture
A próxima classe que você vai criar é a classe ImageCapture . Esta classe é responsável por:
- Capturar uma imagem usando a câmera HoloLens e armazená-la na pasta do aplicativo.
- Capturando gestos de toque do usuário.
Para criar esta classe:
Vá para a pasta Scripts que você criou anteriormente.
Clique com o botão direito do mouse dentro da pasta, Create > C# Script. Chame o script ImageCapture.
Clique duas vezes no novo script ImageCapture para abri-lo com o Visual Studio.
Adicione os seguintes namespaces à parte superior do arquivo:
using System.IO; using System.Linq; using UnityEngine; using UnityEngine.XR.WSA.Input; using UnityEngine.XR.WSA.WebCam;Em seguida, adicione as seguintes variáveis dentro da classe ImageCapture, acima do método Start():
public static ImageCapture instance; public int tapsCount; private PhotoCapture photoCaptureObject = null; private GestureRecognizer recognizer; private bool currentlyCapturing = false;
A variável tapsCount armazenará o número de gestos de toque capturados do usuário. Este número é usado na nomeação das imagens capturadas.
O código para os métodos Awake() e Start() agora precisa ser adicionado. Estes serão chamados quando a classe inicializar:
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(); }Implemente um manipulador que será chamado quando ocorrer um gesto de toque.
/// <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 toques capturados do usuário e usa a posição atual do cursor para determinar onde posicionar um novo Label.
Esse método, em seguida, chama o método ExecuteImageCaptureAndAnalysis() para iniciar a funcionalidade principal deste aplicativo.
Uma vez que uma imagem tenha sido capturada e armazenada, os seguintes manipuladores serão chamados. Se o processo for bem-sucedido, o resultado é passado para o VisionManager (que você ainda não criou) 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()); }Em seguida, adicione o método que o aplicativo usa 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 ponto, você notará um erro aparecendo no Painel do Console do Editor Unity. Isso ocorre porque o código faz referência à classe VisionManager que você criará no próximo capítulo.
Capítulo 7 – Chamada para o Azure e Análise de Imagem
O último script que você precisa criar é a classe VisionManager .
Esta classe é responsável por:
- Carregando a imagem mais recente capturada como uma matriz de bytes.
- Enviar a matriz de bytes para sua instância do Serviço de API do Azure Computer Vision para análise.
- Recebendo a resposta como uma cadeia de caracteres JSON.
- Desserializando a resposta e passando as Tags resultantes para a classe ResultsLabel .
Para criar esta classe:
Clique duas vezes na pasta Scripts para abri-la.
Clique com o botão direito do mouse dentro da pasta Scripts , clique em Criar > script C#. Nomeie o script VisionManager.
Clique duas vezes no novo script para abri-lo com o Visual Studio.
Atualize os namespaces para serem iguais aos seguintes, na parte superior da classe VisionManager :
using System; using System.Collections; using System.Collections.Generic; using System.IO; using UnityEngine; using UnityEngine.Networking;Na parte superior do script, dentro da classe VisionManager (acima do método Start(), agora você precisa criar duas Classes que representarão a resposta JSON desserializada 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 ter o atributo [System.Serializable] adicionado antes da declaração para poder ser desserializado com as bibliotecas Unity.
Na classe VisionManager, você 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 inserir sua chave de autenticação na variável authorizationKey . Você terá anotado sua Chave de Autenticação no início deste curso, Capítulo 1.
Aviso
A variável visionAnalysisEndpoint pode ser diferente da especificada neste exemplo. O west-us refere-se estritamente às instâncias de serviço criadas para a região oeste dos EUA. Atualize isso com o URL do seu ponto final, aqui estão alguns exemplos de como isso 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 - Leste da Austrália:
https://australiaeast.api.cognitive.microsoft.com/vision/v1.0/analyze?visualFeatures=Tags
- Europa Ocidental:
Código para Awake agora precisa ser adicionado.
private void Awake() { // allows this instance to behave like a singleton instance = this; }Em seguida, adicione a corotina (com o método de fluxo estático abaixo dela), 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); }Certifique-se de salvar suas alterações no Visual Studio antes de retornar ao Unity.
De volta ao Editor Unity, clique e arraste as classes VisionManager e ImageCapture da pasta Scripts para o objeto Main Camera no Painel Hierarchy.
Capítulo 8 – Antes de construir
Para realizar um teste completo do seu aplicativo, você precisará fazer o sideload dele em seu HoloLens. Antes de o fazer, certifique-se de que:
- Todas as configurações mencionadas no Capítulo 2 estão definidas corretamente.
- Todos os scripts são anexados ao objeto Main Camera .
- Todos os campos no painel principal do inspetor da câmera são atribuídos corretamente.
- Certifique-se de inserir sua chave de autenticação na variável authorizationKey .
- Certifique-se de que você também tenha verificado seu ponto de extremidade no script do VisionManager e que ele esteja alinhado à sua região (este documento usa west-us por padrão).
Capítulo 9 – Criar a solução UWP e fazer sideload do aplicativo
Tudo o que é necessário para a seção Unity deste projeto já foi concluído, então é hora de construí-lo a partir de Unity.
Navegue até Build Settings - File > Build Settings...
Na janela Configurações de compilação, clique em Compilar.
Se ainda não tiver, marque Unity C# Projects.
Clique em Compilar. Unity irá iniciar uma janela do Explorador de Arquivos, onde você precisa criar e, em seguida, selecionar uma pasta para construir o aplicativo. Crie essa pasta agora e nomeie-a como App. Em seguida, com a pasta App selecionada, pressione Select Folder.
Unity começará a construir seu projeto para a pasta App .
Assim que o Unity terminar de construir (pode levar algum tempo), ele abrirá uma janela do Explorador de Arquivos no local da sua compilação (verifique sua barra de tarefas, pois nem sempre ela aparecerá acima de suas janelas, mas notificará você sobre a adição de uma nova janela).
Capítulo 10 – Implantar no HoloLens
Para implantar no HoloLens:
Você precisará do endereço IP do seu HoloLens (para implantação remota) e para garantir que seu HoloLens esteja no modo de desenvolvedor. Para tal:
- Enquanto estiver a usar o HoloLens, abra as Definições.
- Ir para Rede & Opções Avançadas de Wi-Fi > da Internet >
- Observe o endereço IPv4 .
- Em seguida, navegue de volta para Configurações e, em seguida, para Atualizar & Segurança > para desenvolvedores
- Defina o modo de desenvolvedor ativado.
Navegue até sua nova compilação Unity (a pasta App) e abra o arquivo de solução com o Visual Studio.
Na Configuração da Solução, selecione Depurar.
Na Plataforma de Solução, selecione x86, Máquina Remota.
Vá para o menu Build e clique em Deploy Solution, para fazer sideload do aplicativo para o seu HoloLens.
Seu aplicativo agora deve aparecer na lista de aplicativos instalados no seu HoloLens, pronto para ser lançado!
Nota
Para implantar no fone de ouvido imersivo, defina a Plataforma de Solução como Máquina Local e defina a Configuração como Depurar, com x86 como Plataforma. Em seguida, implante na máquina local, usando o menu Compilar, selecionando Implantar solução.
Seu aplicativo de API de Visão Computacional concluído
Parabéns, você criou um aplicativo de realidade mista que aproveita a API de Visão de Computador do Azure para reconhecer objetos do mundo real e exibir confiança do que foi visto.
Exercícios de bónus
Exercício 1
Assim como você usou o parâmetro Tags (como evidenciado dentro do endpoint usado dentro do VisionManager), estenda o aplicativo para detetar outras informações, dê uma olhada em quais outros parâmetros você tem acesso AQUI.
Exercício 2
Exiba os dados retornados do Azure, de forma mais conversacional e legível, talvez ocultando os números. Como se um bot pudesse estar falando com o usuário.