Início Rápido: Análise de Imagem

Use a biblioteca cliente Image Analysis para C# para analisar uma imagem à procura de etiquetas de conteúdo. Este quickstart define um método, AnalyzeImageUrl, que utiliza o objeto cliente para analisar uma imagem remota e imprimir os resultados.

Documentação de referência | Código-fonte da biblioteca | Package (NuGet) | Samples

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• A versão Visual Studio IDE ou atual de .NET Core.
• Depois de tiveres a tua subscrição Azure, cria um recurso Imagem Digitalizada no portal Azure para obter a tua chave e endpoint. Depois de ser implementado, selecione Ir para o recurso.
  • Precisa da chave e do endpoint do recurso que cria para ligar a sua aplicação ao Azure Vision no Foundry Tools.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreve as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se o recurso que criou na secção de Pré-requisitos foi implementado com sucesso, selecione Ir para o recurso em Próximos passos. Pode encontrar a sua chave e endpoint em Gestão de Recursos na página de Chaves e Endpoint do recurso Face. A tua chave de recurso não é a mesma que o teu ID de subscrição do Azure.

Para definir a variável de ambiente para a sua chave e endpoint, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_KEY variável de ambiente, substitui <your_key> por uma das chaves do teu recurso.
• Para definir a VISION_ENDPOINT variável de ambiente, substitua <your_endpoint> pelo endpoint do seu recurso.

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Analisar a imagem

1. Crie uma nova aplicação C#.

   • Visual Studio IDE
   • CLI

   Usando o Visual Studio, crie uma nova aplicação .NET Core.

   Instalar a biblioteca cliente

   Depois de criar um novo projeto, instale a biblioteca cliente clicando com o botão direito na solução do projeto no Explorador de Soluções e selecionando Gerir Pacotes NuGet. No gestor de pacotes que abre selecionar Browse, marque Incluir pré-lançamento e procure por Microsoft.Azure.CognitiveServices.Vision.ComputerVision. Selecione a versão 7.0.0e depois Instalar.

2. A partir do diretório do projeto, abre o ficheiro Program.cs no teu editor ou IDE preferido. Cole o seguinte código:

   using System;
   using System.Collections.Generic;
   using Microsoft.Azure.CognitiveServices.Vision.ComputerVision;
   using Microsoft.Azure.CognitiveServices.Vision.ComputerVision.Models;
   using System.Threading.Tasks;
   using System.IO;
   using Newtonsoft.Json;
   using Newtonsoft.Json.Linq;
   using System.Threading;
   using System.Linq;
   
   namespace ComputerVisionQuickstart
   {
       class Program
       {
           // Add your Computer Vision key and endpoint
           static string key = Environment.GetEnvironmentVariable("VISION_KEY");
           static string endpoint = Environment.GetEnvironmentVariable("VISION_ENDPOINT");
   
           // URL image used for analyzing an image (image of puppy)
           private const string ANALYZE_URL_IMAGE = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/landmark.jpg";
   
           static void Main(string[] args)
           {
               Console.WriteLine("Azure Cognitive Services Computer Vision - .NET quickstart example");
               Console.WriteLine();
   
               // Create a client
               ComputerVisionClient client = Authenticate(endpoint, key);
   
               // Analyze an image to get features and other properties.
               AnalyzeImageUrl(client, ANALYZE_URL_IMAGE).Wait();
           }
   
           /*
            * AUTHENTICATE
            * Creates a Computer Vision client used by each example.
            */
           public static ComputerVisionClient Authenticate(string endpoint, string key)
           {
               ComputerVisionClient client =
                 new ComputerVisionClient(new ApiKeyServiceClientCredentials(key))
                 { Endpoint = endpoint };
               return client;
           }
          
           public static async Task AnalyzeImageUrl(ComputerVisionClient client, string imageUrl)
           {
               Console.WriteLine("----------------------------------------------------------");
               Console.WriteLine("ANALYZE IMAGE - URL");
               Console.WriteLine();
   
               // Creating a list that defines the features to be extracted from the image. 
   
               List<VisualFeatureTypes?> features = new List<VisualFeatureTypes?>()
               {
                   VisualFeatureTypes.Tags
               };
   
               Console.WriteLine($"Analyzing the image {Path.GetFileName(imageUrl)}...");
               Console.WriteLine();
               // Analyze the URL image 
               ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures: features);
   
               // Image tags and their confidence score
               Console.WriteLine("Tags:");
               foreach (var tag in results.Tags)
               {
                   Console.WriteLine($"{tag.Name} {tag.Confidence}");
               }
               Console.WriteLine();
           }
       }
   }
   

   Importante

   Recomendamos a autenticação do Microsoft Entra ID com identidades geridas para recursos do Azure, para evitar armazenar credenciais nas suas aplicações que correm na nuvem.

   Use as chaves API com cautela. Não incluas a chave API diretamente no teu código e nunca a publiques publicamente. Se usar chaves API, guarde-as de forma segura no Azure Key Vault, rode as chaves regularmente e restrinja o acesso ao Azure Key Vault usando controlo de acesso baseado em funções e restrições de acesso à rede. Para mais informações sobre o uso seguro das chaves da API nas suas aplicações, consulte Chaves da API com Azure Key Vault.

   Para mais informações sobre a segurança dos serviços de IA, consulte Autenticar pedidos para Serviços de IA do Azure.

3. Executar a aplicação

   • Visual Studio IDE
   • CLI

   Execute a aplicação clicando no botão Depurar no topo da janela do IDE.

Produção

A saída da sua operação deve ser semelhante ao seguinte exemplo.

----------------------------------------------------------
ANALYZE IMAGE - URL

Analyzing the image sample16.png...

Tags:
grass 0.9957543611526489
dog 0.9939157962799072
mammal 0.9928356409072876
animal 0.9918001890182495
dog breed 0.9890419244766235
pet 0.974603533744812
outdoor 0.969241738319397
companion dog 0.906731367111206
small greek domestic dog 0.8965123891830444
golden retriever 0.8877675533294678
labrador retriever 0.8746421337127686
puppy 0.872604250907898
ancient dog breeds 0.8508287668228149
field 0.8017748594284058
retriever 0.6837497353553772
brown 0.6581960916519165

Liberar recursos

Se quiseres limpar e remover uma subscrição do Foundry Tools, podes eliminar o recurso ou grupo de recursos. Eliminar o grupo de recursos também elimina quaisquer outros recursos associados a ele.

• Portal Azure
• CLI do Azure

Conteúdo relacionado

Neste quickstart, aprendeste a instalar a biblioteca cliente Image Analysis e a fazer chamadas básicas de análise de imagens. De seguida, saiba mais sobre as funcionalidades da API de Análise de Imagens.

• O que é a Análise de Imagens?
• Código-fonte deste exemplo em GitHub

Use a biblioteca cliente Image Analysis para Python para analisar uma imagem remota à procura de etiquetas de conteúdo.

Documentação de referência | Código-fonte da biblioteca | Package (PiPy) | Samples

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• Python 3.x.
  • A sua instalação Python deve incluir pip. Podes verificar se tens pip instalado correndo pip --version na linha de comandos. Obtenha pip instalando a versão mais recente do Python.
• Depois de tiveres a tua subscrição Azure, cria um recurso Imagem Digitalizada no portal Azure para obter a tua chave e endpoint. Depois de ser implementado, selecione Ir para o recurso.
  • Precisa da chave e do endpoint do recurso que cria para ligar a sua aplicação ao Azure Vision no Foundry Tools.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreve as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se o recurso que criou na secção de Pré-requisitos foi implementado com sucesso, selecione Ir para o recurso em Próximos passos. Pode encontrar a sua chave e endpoint em Gestão de Recursos na página de Chaves e Endpoint do recurso Face. A tua chave de recurso não é a mesma que o teu ID de subscrição do Azure.

Para definir a variável de ambiente para a sua chave e endpoint, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_KEY variável de ambiente, substitui <your_key> por uma das chaves do teu recurso.
• Para definir a VISION_ENDPOINT variável de ambiente, substitua <your_endpoint> pelo endpoint do seu recurso.

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Analisar a imagem

1. Instala a biblioteca do cliente.

   Pode instalar a biblioteca cliente com:

   pip install --upgrade azure-cognitiveservices-vision-computervision
   

   Também instala a biblioteca Pillow.

   pip install pillow
   

2. Crie uma nova aplicação Python.

   Crie um novo ficheiro Python. Pode nomeá-lo quickstart-file.py, por exemplo.

3. Abra quickstart-file.py num editor de texto ou IDE e cole o código seguinte.

   from azure.cognitiveservices.vision.computervision import ComputerVisionClient
   from azure.cognitiveservices.vision.computervision.models import OperationStatusCodes
   from azure.cognitiveservices.vision.computervision.models import VisualFeatureTypes
   from msrest.authentication import CognitiveServicesCredentials
   
   from array import array
   import os
   from PIL import Image
   import sys
   import time
   
   '''
   Authenticate
   Authenticates your credentials and creates a client.
   '''
   subscription_key = os.environ["VISION_KEY"]
   endpoint = os.environ["VISION_ENDPOINT"]
   
   computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))
   '''
   END - Authenticate
   '''
   
   '''
   Quickstart variables
   These variables are shared by several examples
   '''
   # Images used for the examples: Describe an image, Categorize an image, Tag an image, 
   # Detect faces, Detect adult or racy content, Detect the color scheme, 
   # Detect domain-specific content, Detect image types, Detect objects
   images_folder = os.path.join (os.path.dirname(os.path.abspath(__file__)), "images")
   remote_image_url = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/landmark.jpg"
   '''
   END - Quickstart variables
   '''
   
   
   '''
   Tag an Image - remote
   This example returns a tag (key word) for each thing in the image.
   '''
   print("===== Tag an image - remote =====")
   # Call API with remote image
   tags_result_remote = computervision_client.tag_image(remote_image_url )
   
   # Print results with confidence score
   print("Tags in the remote image: ")
   if (len(tags_result_remote.tags) == 0):
       print("No tags detected.")
   else:
       for tag in tags_result_remote.tags:
           print("'{}' with confidence {:.2f}%".format(tag.name, tag.confidence * 100))
   print()
   '''
   END - Tag an Image - remote
   '''
   print("End of Computer Vision quickstart.")
   

4. Executa a aplicação usando o python comando no teu ficheiro de início rápido.

   python quickstart-file.py
   

Produção

A saída da operação deve assemelhar-se ao seguinte exemplo.

===== Tag an image - remote =====
Tags in the remote image:
'outdoor' with confidence 99.00%
'building' with confidence 98.81%
'sky' with confidence 98.21%
'stadium' with confidence 98.17%
'ancient rome' with confidence 96.16%
'ruins' with confidence 95.04%
'amphitheatre' with confidence 93.99%
'ancient roman architecture' with confidence 92.65%
'historic site' with confidence 89.55%
'ancient history' with confidence 89.54%
'history' with confidence 86.72%
'archaeological site' with confidence 84.41%
'travel' with confidence 65.85%
'large' with confidence 61.02%
'city' with confidence 56.57%

End of Azure Vision quickstart.

Liberar recursos

Se quiseres limpar e remover uma subscrição do Foundry Tools, podes eliminar o recurso ou grupo de recursos. Eliminar o grupo de recursos também elimina quaisquer outros recursos associados a ele.

• Portal Azure
• CLI do Azure

Próximo passo

Neste quickstart, aprendeste a instalar a biblioteca cliente Image Analysis e a fazer chamadas básicas de análise de imagens. Em seguida, saiba mais sobre as funcionalidades da API de Análise de Imagens.

• O que é a Análise de Imagens?
• Código-fonte deste exemplo em GitHub

Use a biblioteca cliente Image Analysis para Java para analisar uma imagem remota em busca de etiquetas, descrição de texto, rostos, conteúdo adulto e mais.

Documentação de referência | Código-fonte da biblioteca |Artifact (Maven) | Samples

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• A versão atual do Kit de Desenvolvimento Java (JDK).
• A ferramenta de compilação Gradle, ou outro gestor de dependências.
• Depois de tiveres a tua subscrição Azure, cria um recurso Imagem Digitalizada no portal Azure para obter a tua chave e endpoint. Depois de ser implementado, selecione Ir para o recurso.
  • Precisa da chave e do endpoint do recurso que cria para ligar a sua aplicação ao Azure Vision no Foundry Tools.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreve as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se o recurso que criou na secção de Pré-requisitos foi implementado com sucesso, selecione Ir para o recurso em Próximos passos. Pode encontrar a sua chave e endpoint em Gestão de Recursos na página de Chaves e Endpoint do recurso Face. A tua chave de recurso não é a mesma que o teu ID de subscrição do Azure.

Para definir a variável de ambiente para a sua chave e endpoint, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_KEY variável de ambiente, substitui <your_key> por uma das chaves do teu recurso.
• Para definir a VISION_ENDPOINT variável de ambiente, substitua <your_endpoint> pelo endpoint do seu recurso.

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Analisar a imagem

1. Crie um novo projeto Gradle.

   Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue até lá.

   mkdir myapp && cd myapp
   

   Executa o gradle init comando a partir do teu diretório de trabalho. Este comando cria ficheiros de compilação essenciais para o Gradle, incluindo build.gradle.kts, que é usado em tempo de execução para criar e configurar a sua aplicação.

   gradle init --type basic
   

   Quando solicitado a escolher um DSL, selecione Kotlin.

2. Instala a biblioteca do cliente.

   Este quickstart utiliza o gestor de dependências do Gradle. Pode encontrar a biblioteca cliente e informações para outros gestores de dependências no Repositório Central Maven.

   Localiza build.gradle.kts e abre-o com o teu IDE ou editor de texto preferido. Depois copia e cola a configuração de compilação seguinte no ficheiro. Esta configuração define o projeto como uma aplicação Java cujo ponto de entrada é a classe ImageAnalysisQuickstart. Importa a biblioteca do Azure Vision.

   plugins {
       java
       application
   }
   application { 
       mainClass.set("ImageAnalysisQuickstart")
   }
   repositories {
       mavenCentral()
   }
   dependencies {
       implementation(group = "com.microsoft.azure.cognitiveservices", name = "azure-cognitiveservices-computervision", version = "1.0.9-beta")
   }
   

3. Crie um ficheiro Java.

   A partir do seu diretório de trabalho, execute o seguinte comando para criar uma pasta de origem do projeto:

   mkdir -p src/main/java
   

   Navega até à nova pasta e cria um ficheiro chamado ImageAnalysisQuickstart.java.

4. Abra ImageAnalysisQuickstart.java no seu editor ou IDE preferido e cole o código seguinte.

   import com.microsoft.azure.cognitiveservices.vision.computervision.*;
   import com.microsoft.azure.cognitiveservices.vision.computervision.implementation.ComputerVisionImpl;
   import com.microsoft.azure.cognitiveservices.vision.computervision.models.*;
   
   import java.io.*;
   import java.nio.file.Files;
   
   import java.util.ArrayList;
   import java.util.List;
   import java.util.UUID;
   
   public class ImageAnalysisQuickstart {
   
       // Use environment variables
       static String key = System.getenv("VISION_KEY");
       static String endpoint = System.getenv("VISION_ENDPOINT");
   
       public static void main(String[] args) {
           
           System.out.println("\nAzure Cognitive Services Computer Vision - Java Quickstart Sample");
   
           // Create an authenticated Computer Vision client.
           ComputerVisionClient compVisClient = Authenticate(key, endpoint); 
   
           // Analyze local and remote images
           AnalyzeRemoteImage(compVisClient);
   
       }
   
       public static ComputerVisionClient Authenticate(String key, String endpoint){
           return ComputerVisionManager.authenticate(key).withEndpoint(endpoint);
       }
   
   
       public static void AnalyzeRemoteImage(ComputerVisionClient compVisClient) {
           /*
            * Analyze an image from a URL:
            *
            * Set a string variable equal to the path of a remote image.
            */
           String pathToRemoteImage = "https://github.com/Azure-Samples/cognitive-services-sample-data-files/raw/master/ComputerVision/Images/faces.jpg";
   
           // This list defines the features to be extracted from the image.
           List<VisualFeatureTypes> featuresToExtractFromRemoteImage = new ArrayList<>();
           featuresToExtractFromRemoteImage.add(VisualFeatureTypes.TAGS);
   
           System.out.println("\n\nAnalyzing an image from a URL ...");
   
           try {
               // Call the Computer Vision service and tell it to analyze the loaded image.
               ImageAnalysis analysis = compVisClient.computerVision().analyzeImage().withUrl(pathToRemoteImage)
                       .withVisualFeatures(featuresToExtractFromRemoteImage).execute();
   
   
               // Display image tags and confidence values.
               System.out.println("\nTags: ");
               for (ImageTag tag : analysis.tags()) {
                   System.out.printf("\'%s\' with confidence %f\n", tag.name(), tag.confidence());
               }
           }
   
           catch (Exception e) {
               System.out.println(e.getMessage());
               e.printStackTrace();
           }
       }
       // END - Analyze an image from a URL.
   
   }
   

5. Navega de volta à pasta raiz do projeto e depois constrói a aplicação com:

   gradle build
   

   Execute-o com o seguinte comando:

   gradle run
   

Produção

A saída da operação deve assemelhar-se ao seguinte exemplo.

Azure Vision - Java Quickstart Sample

Analyzing an image from a URL ...

Tags:
'person' with confidence 0.998895
'human face' with confidence 0.997437
'smile' with confidence 0.991973
'outdoor' with confidence 0.985962
'happy' with confidence 0.969785
'clothing' with confidence 0.961570
'friendship' with confidence 0.946441
'tree' with confidence 0.917331
'female person' with confidence 0.890976
'girl' with confidence 0.888741
'social group' with confidence 0.872044
'posing' with confidence 0.865493
'adolescent' with confidence 0.857371
'love' with confidence 0.852553
'laugh' with confidence 0.850097
'people' with confidence 0.849922
'lady' with confidence 0.844540
'woman' with confidence 0.818172
'group' with confidence 0.792975
'wedding' with confidence 0.615252
'dress' with confidence 0.517169

Liberar recursos

Se quiseres limpar e remover uma subscrição do Foundry Tools, podes eliminar o recurso ou grupo de recursos. Eliminar o grupo de recursos também elimina quaisquer outros recursos associados a ele.

• Portal Azure
• CLI do Azure

Próximo passo

Neste quickstart, aprendeste a instalar a biblioteca cliente Image Analysis e a fazer chamadas básicas de análise de imagens. Em seguida, saiba mais sobre as funcionalidades da API de Análise de Imagens.

• O que é a Análise de Imagens?
• Código-fonte deste exemplo em GitHub

Use a biblioteca cliente Image Analysis para JavaScript para analisar uma imagem remota à procura de etiquetas de conteúdo.

Documentação | de referênciaPacote (npm) | Exemplos

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• A versão atual de Node.js.
• Depois de tiveres a tua subscrição Azure, cria um recurso Imagem Digitalizada no portal Azure para obter a tua chave e endpoint. Depois de ser implementado, selecione Ir para o recurso.
  • Precisa da chave e do endpoint do recurso que cria para ligar a sua aplicação ao Azure Vision no Foundry Tools.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreve as tuas credenciais para variáveis de ambiente na máquina local que executa a aplicação.

Vai ao portal do Azure. Se o recurso que criou na secção de Pré-requisitos foi implementado com sucesso, selecione Ir para o recurso em Próximos passos. Pode encontrar a sua chave e endpoint em Gestão de Recursos na página de Chaves e Endpoint do recurso Face. A tua chave de recurso não é a mesma que o teu ID de subscrição do Azure.

Para definir a variável de ambiente para a sua chave e endpoint, abra uma janela de consola e siga as instruções do seu sistema operativo e ambiente de desenvolvimento.

• Para definir a VISION_KEY variável de ambiente, substitui <your_key> por uma das chaves do teu recurso.
• Para definir a VISION_ENDPOINT variável de ambiente, substitua <your_endpoint> pelo endpoint do seu recurso.

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Analisar a imagem

1. Criar uma nova aplicação Node.js

   Numa janela de consola (como cmd, PowerShell ou Bash), crie um novo diretório para a sua aplicação e navegue até lá.

   mkdir myapp && cd myapp
   

   Executa o npm init comando para criar uma aplicação Node.js com um ficheiro package.json.

   npm init
   

   Instalar a biblioteca cliente

   Instale os pacotes npm ms-rest-azure e @azure/cognitiveservices-computervision:

   npm install @azure/cognitiveservices-computervision
   

   Também instala o módulo assíncrono:

   npm install async
   

   O ficheiro da sua aplicação package.json é atualizado com as dependências.

   Criar um novo ficheiro, index.js.

2. Abra index.js num editor de texto e cole o código seguinte.

   'use strict';
   
   const async = require('async');
   const fs = require('fs');
   const https = require('https');
   const path = require("path");
   const createReadStream = require('fs').createReadStream
   const sleep = require('util').promisify(setTimeout);
   const ComputerVisionClient = require('@azure/cognitiveservices-computervision').ComputerVisionClient;
   const ApiKeyCredentials = require('@azure/ms-rest-js').ApiKeyCredentials;
   
   /**
    * AUTHENTICATE
    * This single client is used for all examples.
    */
   const key = process.env.VISION_KEY;
   const endpoint = process.env.VISION_ENDPOINT;
   
   
   const computerVisionClient = new ComputerVisionClient(
     new ApiKeyCredentials({ inHeader: { 'Ocp-Apim-Subscription-Key': key } }), endpoint);
   /**
    * END - Authenticate
    */
   
   
   function computerVision() {
     async.series([
       async function () {
   
         /**
          * DETECT TAGS  
          * Detects tags for an image, which returns:
          *     all objects in image and confidence score.
          */
         console.log('-------------------------------------------------');
         console.log('DETECT TAGS');
         console.log();
   
         // Image of different kind of dog.
         const tagsURL = 'https://github.com/Azure-Samples/cognitive-services-sample-data-files/blob/master/ComputerVision/Images/house.jpg';
   
         // Analyze URL image
         console.log('Analyzing tags in image...', tagsURL.split('/').pop());
         const tags = (await computerVisionClient.analyzeImage(tagsURL, { visualFeatures: ['Tags'] })).tags;
         console.log(`Tags: ${formatTags(tags)}`);
   
         // Format tags for display
         function formatTags(tags) {
           return tags.map(tag => (`${tag.name} (${tag.confidence.toFixed(2)})`)).join(', ');
         }
         /**
          * END - Detect Tags
          */
         console.log();
         console.log('-------------------------------------------------');
         console.log('End of quickstart.');
   
       },
       function () {
         return new Promise((resolve) => {
           resolve();
         })
       }
     ], (err) => {
       throw (err);
     });
   }
   
   computerVision();
   

3. Executa a aplicação com o node comando no teu ficheiro de início rápido.

   node index.js
   

Produção

A saída da operação deve assemelhar-se ao seguinte exemplo.

-------------------------------------------------
DETECT TAGS

Analyzing tags in image... sample16.png
Tags: grass (1.00), dog (0.99), mammal (0.99), animal (0.99), dog breed (0.99), pet (0.97), outdoor (0.97), companion dog (0.91), small greek domestic dog (0.90), golden retriever (0.89), labrador retriever (0.87), puppy (0.87), ancient dog breeds (0.85), field (0.80), retriever (0.68), brown (0.66)

-------------------------------------------------
End of quickstart.

Liberar recursos

Se quiseres limpar e remover uma subscrição do Foundry Tools, podes eliminar o recurso ou grupo de recursos. Eliminar o grupo de recursos também elimina quaisquer outros recursos associados a ele.

• Portal Azure
• CLI do Azure

Próximo passo

Neste quickstart, aprendeste a instalar a biblioteca cliente Image Analysis e a fazer chamadas básicas de análise de imagens. Em seguida, saiba mais sobre as funcionalidades da API de Análise de Imagens.

• O que é a Análise de Imagens?
• Código-fonte deste exemplo em GitHub

Use a API REST de Análise de Imagens para analisar uma imagem à procura de etiquetas.

Pré-requisitos

• Uma subscrição do Azure. Podes criar um gratuitamente.
• Depois de tiveres a tua subscrição Azure, cria um recurso Imagem Digitalizada no portal Azure para obter a tua chave e endpoint. Depois de ser implementado, selecione Ir para o recurso.
  • Precisa da chave e do endpoint do recurso que cria para ligar a sua aplicação ao Azure Vision no Foundry Tools.
  • Podes usar o escalão de preços gratuito (F0) para experimentar o serviço, e depois fazer um upgrade para um nível pago para produção.
• cURL instalado.

Analisar uma imagem

Para analisar uma imagem em busca de várias características visuais, siga os seguintes passos:

1. Copie o comando seguinte para um editor de texto.

   curl.exe -H "Ocp-Apim-Subscription-Key: <yourKey>" -H "Content-Type: application/json" "https://westcentralus.api.cognitive.microsoft.com/vision/v3.2/analyze?visualFeatures=Tags" -d "{'url':'https://learn.microsoft.com/azure/ai-services/computer-vision/media/quickstarts/presentation.png'}"
   

2. Faça as seguintes alterações no comando sempre que necessário:

   1. Substitua o valor de <yourKey> pela chave do seu recurso Imagem Digitalizada.
   2. Substitua a primeira parte do URL do pedido (westcentralus.api.cognitive.microsoft.com) pelo seu próprio URL de endpoint.

      Nota

      Novos recursos criados após 1 de julho de 2019 irão utilizar nomes de subdomínio personalizados. Para mais informações e uma lista completa de endpoints regionais, consulte Nomes de subdomínio personalizados para Foundry Tools.

   3. Opcionalmente, altere a URL da imagem no corpo do pedido (https://learn.microsoft.com/azure/ai-services/computer-vision/media/quickstarts/presentation.png) para a URL de uma imagem diferente a ser analisada.

3. Abre uma janela de prompt de comandos.

4. Cola o comando editado curl do editor de texto na janela do prompt de comandos e depois executa o comando.

Analise a resposta

Uma resposta bem-sucedida é devolvida em formato JSON. A aplicação de exemplo analisa e apresenta uma resposta bem-sucedida na janela do prompt de comandos, semelhante ao seguinte exemplo:

{
   "tags":[
      {
         "name":"text",
         "confidence":0.9992657899856567
      },
      {
         "name":"post-it note",
         "confidence":0.9879657626152039
      },
      {
         "name":"handwriting",
         "confidence":0.9730165004730225
      },
      {
         "name":"rectangle",
         "confidence":0.8658561706542969
      },
      {
         "name":"paper product",
         "confidence":0.8561884760856628
      },
      {
         "name":"purple",
         "confidence":0.5961999297142029
      }
   ],
   "requestId":"2788adfc-8cfb-43a5-8fd6-b3a9ced35db2",
   "metadata":{
      "height":945,
      "width":1000,
      "format":"Jpeg"
   },
   "modelVersion":"2021-05-01"
}

Próximo passo

Neste quickstart, aprendeste a fazer chamadas básicas de análise de imagem usando a API REST. Em seguida, saiba mais sobre as funcionalidades da API de Análise de Imagens.

• O que é a Análise de Imagens?