Guia de início rápido: análise de imagem

Artigo
10/31/2024

Este artigo explica como configurar um script básico de marcação de imagem usando a API REST de Análise de Imagem ou bibliotecas de cliente. O serviço Analyze Image fornece algoritmos de IA para processar imagens e retornar informações sobre seus recursos visuais. Siga estas etapas para instalar um pacote em seu aplicativo e experimente o código de exemplo.

Use a biblioteca de cliente de Análise de Imagem para C# para analisar uma imagem para tags de conteúdo. Este guia de início rápido define um método, AnalyzeImageUrl, que usa o objeto cliente para analisar uma imagem remota e imprimir os resultados.

Documentação | de referência Pacote de código-fonte | da biblioteca (NuGet)Amostras |

Gorjeta

Você também pode analisar uma imagem local. Consulte os métodos ComputerVisionClient , como AnalyzeImageInStreamAsync. Ou, consulte o código de exemplo no GitHub para cenários que envolvem imagens locais.

Gorjeta

A API Analyze Image pode fazer muitas operações diferentes além de gerar tags de imagem. Consulte o guia de instruções da Análise de Imagem para obter exemplos que mostram todos os recursos disponíveis.

Pré-requisitos

Uma subscrição do Azure. Você pode criar um gratuitamente.
O IDE do Visual Studio ou a versão atual do .NET Core.
Depois de ter sua assinatura do Azure, crie um recurso de Visão Computacional no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço Azure AI Vision.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Aceda ao portal do Azure. Se o recurso criado na seção Pré-requisitos for implantado com êxito, selecione Ir para o recurso em Próximas etapas. Você pode encontrar sua chave e ponto de extremidade em Gerenciamento de Recursos na página Chaves e Ponto de Extremidade . Sua chave de recurso não é a mesma que sua ID de assinatura do Azure.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Cofre de Chaves do Azure. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

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

Windows
Linux

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc a partir da janela do console para tornar as alterações efetivas.

Analisar imagem

Crie um novo aplicativo C#.
- Visual Studio IDE
- CLI
Usando o Visual Studio, crie um novo aplicativo .NET Core.

Instalar a biblioteca de cliente

Depois de criar um novo projeto, instale a biblioteca de cliente clicando com o botão direito do mouse na solução do projeto no Gerenciador de Soluções e selecionando Gerenciar Pacotes NuGet. No gestor de pacotes que abre, selecione Procurar, marque a caixa Incluir pré-lançamento e procure Microsoft.Azure.CognitiveServices.Vision.ComputerVision. Selecione a versão 7.0.0 e, em seguida, Instalar.
Em uma janela de console (como cmd, PowerShell ou Bash), use o dotnet new comando para criar um novo aplicativo de console com o nome computer-vision-quickstart. Este comando cria um projeto Hello World C# simples com um único arquivo de origem: Program.cs.
```
dotnet new console -n computer-vision-quickstart
```
Altere seu diretório para a pasta do aplicativo recém-criada. Você pode criar o aplicativo com:
```
dotnet build
```
A saída da compilação não deve conter avisos ou erros.
```
...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...
```
Instalar a biblioteca de cliente

No diretório do aplicativo, instale a biblioteca de cliente do Azure AI Vision para .NET com o seguinte comando:
```
dotnet add package Microsoft.Azure.CognitiveServices.Vision.ComputerVision --version 7.0.0
```

No diretório do projeto, abra o arquivo Program.cs em seu editor ou IDE preferido. Cole no 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

Lembre-se de remover a chave do seu código quando terminar e nunca publicá-la publicamente. Para produção, use uma maneira segura de armazenar e acessar suas credenciais, como o Azure Key Vault. Para obter mais informações, consulte Segurança dos serviços de IA do Azure.

Executar a aplicação
- Visual Studio IDE
- CLI
Execute o aplicativo clicando no botão Depurar na parte superior da janela do IDE.
Execute o aplicativo a partir do diretório do aplicativo usando o dotnet run comando.
```
dotnet run
```

Saída

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

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

Clean up resources (Limpar recursos)

Se quiser limpar e remover uma assinatura de serviços do Azure AI, você pode excluir o recurso ou grupo de recursos. A exclusão do grupo de recursos também exclui quaisquer outros recursos associados a ele.

Neste início rápido, você aprendeu como instalar a biblioteca de cliente do Image Analysis e fazer chamadas básicas de análise de imagem. Em seguida, saiba mais sobre os recursos da API de Análise de Imagem.

Chamar a API de análise de imagem

Use a biblioteca de cliente de Análise de Imagem para Python para analisar uma imagem remota para tags de conteúdo.

Gorjeta

Você também pode analisar uma imagem local. Consulte os métodos ComputerVisionClientOperationsMixin , como analyze_image_in_stream. Ou, consulte o código de exemplo no GitHub para cenários que envolvem imagens locais.

Gorjeta

Documentação | de referência Pacote de código-fonte | da biblioteca (PiPy)Amostras |

Pré-requisitos

Uma subscrição do Azure. Você pode criar um gratuitamente.
Python 3.x.
- Sua instalação do Python deve incluir pip. Você pode verificar se você tem pip instalado executando pip --version na linha de comando. Obtenha pip instalando a versão mais recente do Python.
Depois de ter sua assinatura do Azure, crie um recurso de Visão Computacional no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço Azure AI Vision.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Cofre de Chaves do Azure. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

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

Windows
Linux

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc a partir da janela do console para tornar as alterações efetivas.

Analisar imagem

Instale a biblioteca do cliente.

Você pode instalar a biblioteca de cliente com:
```
pip install --upgrade azure-cognitiveservices-vision-computervision
```
Instale também a biblioteca de travesseiros.
```
pip install pillow
```
Crie um novo aplicativo Python.

Crie um novo arquivo Python. Você pode nomeá-lo quickstart-file.py, por exemplo.

Abra quickstart-file.py em um editor de texto ou IDE e cole no código a seguir.

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.")

Execute o aplicativo usando o python comando em seu arquivo de início rápido.
```
python quickstart-file.py
```

Saída

A saída da operação deve se parecer com o exemplo a seguir.

===== 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 AI Vision quickstart.

Clean up resources (Limpar recursos)

Próximo passo

Chamar a API de análise de imagem

Use a biblioteca de cliente de Análise de Imagem para Java para analisar uma imagem remota para tags, descrição de texto, rostos, conteúdo adulto e muito mais.

Gorjeta

Você também pode analisar uma imagem local. Consulte os métodos ComputerVision, como AnalyzeImage. Ou, consulte o código de exemplo no GitHub para cenários que envolvem imagens locais.

Gorjeta

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

Pré-requisitos

Uma subscrição do Azure. Você pode criar um gratuitamente.
A versão atual do Java Development Kit (JDK).
A ferramenta de compilação Gradle ou outro gerenciador de dependência.
Depois de ter sua assinatura do Azure, crie um recurso de Visão Computacional no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço Azure AI Vision.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Cofre de Chaves do Azure. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

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

Windows
Linux

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc a partir da janela do console para tornar as alterações efetivas.

Analisar imagem

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 para a mesma.
```
mkdir myapp && cd myapp
```
Execute o comando a gradle init partir do seu diretório de trabalho. Este comando cria arquivos de compilação essenciais para o Gradle, incluindo build.gradle.kts, que é usado em tempo de execução para criar e configurar seu aplicativo.
```
gradle init --type basic
```
Quando solicitado a escolher uma DSL, selecione Kotlin.
Instale a biblioteca do cliente.

Este guia de início rápido usa o gerenciador de dependência do Gradle. Você pode encontrar a biblioteca do cliente e informações para outros gerenciadores de dependência no Maven Central Repository.

Localize build.gradle.kts e abra-o com o seu IDE ou editor de texto preferido. Em seguida, copie e cole a seguinte configuração de compilação no arquivo. Esta configuração define o projeto como uma aplicação Java cujo ponto de entrada é a classe ImageAnalysisQuickstart. Ele importa a biblioteca do Azure AI 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")
}
```
Crie um arquivo Java.

No diretório de trabalho, execute o seguinte comando para criar uma pasta de origem do projeto:
```
mkdir -p src/main/java
```
Navegue até a nova pasta e crie um arquivo chamado ImageAnalysisQuickstart.java.

Abra ImageAnalysisQuickstart.java em seu editor ou IDE preferido e cole no código a seguir.

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.

}

Navegue de volta para a pasta raiz do projeto e, em seguida, crie o aplicativo com:
```
gradle build
```
Execute-o com o seguinte comando:
```
gradle run
```

Saída

A saída da operação deve se parecer com o exemplo a seguir.

Azure AI 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

Clean up resources (Limpar recursos)

Próximo passo

Chamar a API de análise de imagem

Use a biblioteca de cliente de Análise de Imagem para JavaScript para analisar uma imagem remota para tags de conteúdo.

Gorjeta

Você também pode analisar uma imagem local. Consulte os métodos ComputerVisionClient , como describeImageInStream. Ou, consulte o código de exemplo no GitHub para cenários que envolvem imagens locais.

Gorjeta

Pacote de documentação | de referência (npm) | Amostras

Pré-requisitos

Uma subscrição do Azure. Você pode criar um gratuitamente.
A versão atual do Node.js.
Depois de ter sua assinatura do Azure, crie um recurso de Visão Computacional no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço Azure AI Vision.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.

Criar variáveis de ambiente

Neste exemplo, escreva suas credenciais em variáveis de ambiente na máquina local que executa o aplicativo.

Para definir a variável de ambiente para sua chave e ponto de extremidade, abra uma janela do console e siga as instruções para seu sistema operacional e ambiente de desenvolvimento.

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

Importante

Se você usar uma chave de API, armazene-a com segurança em outro lugar, como no Cofre de Chaves do Azure. Não inclua a chave da API diretamente no seu código e nunca a publique publicamente.

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

Windows
Linux

setx VISION_KEY <your_key>

setx VISION_ENDPOINT <your_endpoint>

Depois de adicionar as variáveis de ambiente, talvez seja necessário reiniciar todos os programas em execução que lerão as variáveis de ambiente, incluindo a janela do console.

export VISION_KEY=<your_key>

export VISION_ENDPOINT=<your_endpoint>

Depois de adicionar as variáveis de ambiente, execute source ~/.bashrc a partir da janela do console para tornar as alterações efetivas.

Analisar imagem

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 para a mesma.
```
mkdir myapp && cd myapp
```
Execute o npm init comando para criar um aplicativo de nó com um arquivo package.json .
```
npm init
```
Instalar a biblioteca de cliente

Instale o pacote e @azure/cognitiveservices-computervision npmms-rest-azure:
```
npm install @azure/cognitiveservices-computervision
```
Instale também o módulo assíncrono:
```
npm install async
```
O arquivo do package.json seu aplicativo é atualizado com as dependências.

Crie um novo arquivo, index.js.

Abra index.js em um editor de texto e cole no código a seguir.

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

Execute a aplicação com o comando node no seu ficheiro de início rápido.
```
node index.js
```

Saída

A saída da operação deve se parecer com o exemplo a seguir.

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

Clean up resources (Limpar recursos)

Próximo passo

Chamar a API de análise de imagem

Use a API REST de análise de imagem para analisar uma imagem para tags.

Gorjeta

Nota

Este guia de início rápido usa comandos cURL para chamar a API REST. Você também pode chamar a API REST usando uma linguagem de programação. Consulte os exemplos do GitHub para obter exemplos em C#, Python, Java e JavaScript.

Pré-requisitos

Uma subscrição do Azure. Você pode criar um gratuitamente.
Depois de ter sua assinatura do Azure, crie um recurso de Visão Computacional no portal do Azure para obter sua chave e ponto de extremidade. Depois de implantar, selecione Ir para recurso.
- Você precisa da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço Azure AI Vision.
- Você pode usar o nível de preço gratuito (F0) para experimentar o serviço e atualizar posteriormente para um nível pago para produção.
cURL instalado.

Analisar uma imagem

Para analisar uma imagem para vários recursos visuais, execute as seguintes etapas:

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'}"

Faça as alterações seguintes ao comando, se for necessário:
1. Substitua o valor de <yourKey> pela chave do seu recurso de Visão Computacional.
2. Substitua a primeira parte do URL de solicitação (westcentralus.api.cognitive.microsoft.com) pelo seu próprio URL de ponto de extremidade.
  
  Nota
  
  Novos recursos criados após 1º de julho de 2019 usarão nomes de subdomínio personalizados. Para obter mais informações e uma lista completa de pontos de extremidade regionais, consulte Nomes de subdomínio personalizados para serviços de IA do Azure.
3. Opcionalmente, altere o URL da imagem no corpo do pedido (https://learn.microsoft.com/azure/ai-services/computer-vision/media/quickstarts/presentation.png) pelo URL de uma imagem diferente a ser analisada.
Abra uma janela da linha de comandos.
Cole o comando editado curl do editor de texto na janela do prompt de comando e execute o comando.

Examinar a resposta

Uma resposta bem-sucedida é retornada no formato JSON. A aplicação de exemplo analisa e apresenta uma resposta de êxito na janela da linha 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 guia de início rápido, você aprendeu como fazer chamadas básicas de análise de imagem usando a API REST. Em seguida, saiba mais sobre os recursos da API Analisar imagem.

Chamar a API de análise de imagem

O que é a Análise de Imagem?

Partilhar via

Guia de início rápido: análise de imagem

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Instalar a biblioteca de cliente

Instalar a biblioteca de cliente

Saída

Clean up resources (Limpar recursos)

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Saída

Clean up resources (Limpar recursos)

Próximo passo

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Saída

Clean up resources (Limpar recursos)

Próximo passo

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Instalar a biblioteca de cliente

Saída

Clean up resources (Limpar recursos)

Próximo passo

Pré-requisitos

Analisar uma imagem

Examinar a resposta

Próximo passo

Comentários

Recursos adicionais

Partilhar via

Guia de início rápido: análise de imagem

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Instalar a biblioteca de cliente

Saída

Clean up resources (Limpar recursos)

Conteúdos relacionados

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Saída

Clean up resources (Limpar recursos)

Próximo passo

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Saída

Clean up resources (Limpar recursos)

Próximo passo

Pré-requisitos

Criar variáveis de ambiente

Analisar imagem

Instalar a biblioteca de cliente

Saída

Clean up resources (Limpar recursos)

Próximo passo

Pré-requisitos

Analisar uma imagem

Examinar a resposta

Próximo passo

Comentários

Recursos adicionais