Guia de início rápido: Usar a biblioteca de clientes ou a API REST de Análise de Imagem

Introdução à API REST ou às bibliotecas de clientes da Análise de Imagem. O serviço de Análise de Imagem fornece algoritmos de IA para processar imagens e retornar informações sobre os recursos visuais delas. Siga essas etapas para instalar um pacote para seu aplicativo e experimentar o código de exemplo para tarefas básicas.

Use a biblioteca de clientes da Análise de Imagem para analisar uma imagem em busca de marcas, descrição de texto, rostos, conteúdo para adulto, entre outros.

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

Pré-requisitos

  • Uma assinatura do Azure – crie uma gratuitamente
  • O IDE do Visual Studio ou a versão atual do .NET Core.
  • Depois de obter sua assinatura do Azure, crie um recurso da Pesquisa Visual Computacional no portal do Azure para obter a chave e o ponto de extremidade. Após a implantação, clique em Ir para o recurso.
    • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço de Pesquisa Visual Computacional. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configurando

Criar um aplicativo em C#

Usando o Visual Studio, crie um aplicativo .NET Core.

Instalar a biblioteca de clientes

Depois de criar um projeto, instale a biblioteca de clientes clicando com o botão direito do mouse na solução do projeto no Gerenciador de Soluções e selecionando Gerenciar Pacotes NuGet. No gerenciador de pacotes aberto, selecione Procurar, marque Incluir pré-lançamento e pesquise Microsoft.Azure.CognitiveServices.Vision.ComputerVision. Selecione a versão 7.0.0 e, em seguida, Instalar.

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

No diretório do projeto, abra o arquivo Program.cs no IDE ou no editor de sua preferência. Adicione as seguintes diretivas using:

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;

Na classe Program do aplicativo, crie variáveis para a chave e o Ponto de Extremidade do Azure do recurso.

// Add your Computer Vision subscription key and endpoint
static string subscriptionKey = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE";
static string endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE";

Importante

Acesse o portal do Azure. Se o recurso da Pesquisa Visual Computacional criado na seção Pré-requisitos tiver sido implantado com êxito, clique no botão Acessar o Recurso em Próximas Etapas. Encontre a chave e o ponto de extremidade na página da chave e do ponto de extremidade do recurso, em gerenciamento de recursos.

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, considere o uso de uma maneira segura de armazenar e acessar suas credenciais. Confira o artigo segurança de Serviços Cognitivos para obter mais informações.

No método Main do aplicativo, adicione chamadas para os métodos usados neste início rápido. Elas serão criadas posteriormente.

// Create a client
ComputerVisionClient client = Authenticate(endpoint, subscriptionKey);

// Analyze an image to get features and other properties.
AnalyzeImageUrl(client, ANALYZE_URL_IMAGE).Wait();

Modelo de objeto

As classes e as interfaces a seguir lidam com alguns dos principais recursos do SDK da Análise de Imagem para .NET.

Nome Descrição
ComputerVisionClient Essa classe é necessária para toda a funcionalidade da Pesquisa Visual Computacional. Você cria uma instância delas com suas informações de assinatura e usa-a para fazer a maioria das operações de imagem.
ComputerVisionClientExtensions Essa classe contém métodos adicionais para o ComputerVisionClient.
VisualFeatureTypes Essa enumeração define os diferentes tipos de análise de imagem que podem ser feitos em uma operação de análise padrão. Especifique um conjunto de valores VisualFeatureTypes dependendo de suas necessidades.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Análise de Imagem para .NET:

Autenticar o cliente

Observação

Este início rápido pressupõe que você já criou variáveis de ambiente para a chave e o ponto de extremidade da Pesquisa Visual Computacional, denominadas COMPUTER_VISION_SUBSCRIPTION_KEY e COMPUTER_VISION_ENDPOINT, respectivamente.

Em um novo método na classe Programa, instancie um cliente com seu ponto de extremidade e sua chave. Crie um objeto ApiKeyServiceClientCredentials com sua chave e use-o com seu ponto de extremidade para criar um objeto ComputerVisionClient .

/*
 * 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;
}

Analisar uma imagem

O código a seguir define um método, AnalyzeImageUrl, que usa o objeto de cliente para analisar uma imagem remota e imprimir os resultados. O método retorna uma descrição de texto, categorização, lista de marcas, rostos detectados, sinalizadores de conteúdo para adulto, cores principais e tipo de imagem.

Dica

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

Configurar imagem de teste

Na classe Program, salve uma referência à URL da imagem que deseja analisar.

// URL image used for analyzing an image (image of puppy)
private const string ANALYZE_URL_IMAGE = "https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png";

Especificar recursos visuais

Defina o novo método para a análise de imagem. Adicione o código abaixo, que especifica os recursos visuais que você deseja extrair na análise. Confira a enumeração VisualFeatureTypes para obter uma lista completa.

/* 
 * ANALYZE IMAGE - URL IMAGE
 * Analyze URL image. Extracts captions, categories, tags, objects, faces, racy/adult/gory content,
 * brands, celebrities, landmarks, color scheme, and image types.
 */
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.Categories, VisualFeatureTypes.Description,
        VisualFeatureTypes.Faces, VisualFeatureTypes.ImageType,
        VisualFeatureTypes.Tags, VisualFeatureTypes.Adult,
        VisualFeatureTypes.Color, VisualFeatureTypes.Brands,
        VisualFeatureTypes.Objects
    };

Chamar a API de Análise

O método AnalyzeImageAsync retorna um objeto ImageAnalysis que contém todas as informações extraídas.

Console.WriteLine($"Analyzing the image {Path.GetFileName(imageUrl)}...");
Console.WriteLine();
// Analyze the URL image 
ImageAnalysis results = await client.AnalyzeImageAsync(imageUrl, visualFeatures: features);

As seções a seguir mostram como analisar essas informações detalhadamente.

Insira um dos blocos de código a seguir no método AnalyzeImageUrl para analisar dados dos recursos visuais solicitados acima. Lembre-se de adicionar um colchete de fechamento no final.

}

Obter a descrição da imagem

O código a seguir obtém a lista de legendas geradas para a imagem. Confira Descrever imagens para obter mais detalhes.

// Sunmarizes the image content.
Console.WriteLine("Summary:");
foreach (var caption in results.Description.Captions)
{
    Console.WriteLine($"{caption.Text} with confidence {caption.Confidence}");
}
Console.WriteLine();

Obter categoria da imagem

O código a seguir obtém a categoria detectada da imagem. Confira Categorizar imagens para obter detalhes.

// Display categories the image is divided into.
Console.WriteLine("Categories:");
foreach (var category in results.Categories)
{
    Console.WriteLine($"{category.Name} with confidence {category.Score}");
}
Console.WriteLine();

Obter marcas da imagem

O código a seguir obtém o conjunto de marcas detectadas na imagem. Confira Marcas de conteúdo para obter mais detalhes.

// Image tags and their confidence score
Console.WriteLine("Tags:");
foreach (var tag in results.Tags)
{
    Console.WriteLine($"{tag.Name} {tag.Confidence}");
}
Console.WriteLine();

Detectar objetos

O código a seguir detecta objetos comuns na imagem e imprime-os no console. Confira Detecção de objetos para obter mais detalhes.

// Objects
Console.WriteLine("Objects:");
foreach (var obj in results.Objects)
{
    Console.WriteLine($"{obj.ObjectProperty} with confidence {obj.Confidence} at location {obj.Rectangle.X}, " +
      $"{obj.Rectangle.X + obj.Rectangle.W}, {obj.Rectangle.Y}, {obj.Rectangle.Y + obj.Rectangle.H}");
}
Console.WriteLine();

Detectar marcas

O código a seguir detecta logotipos e marcas corporativas na imagem e imprime-os no console. Confira Detecção de marca para obter mais detalhes.

// Well-known (or custom, if set) brands.
Console.WriteLine("Brands:");
foreach (var brand in results.Brands)
{
    Console.WriteLine($"Logo of {brand.Name} with confidence {brand.Confidence} at location {brand.Rectangle.X}, " +
      $"{brand.Rectangle.X + brand.Rectangle.W}, {brand.Rectangle.Y}, {brand.Rectangle.Y + brand.Rectangle.H}");
}
Console.WriteLine();

Detectar faces

O código a seguir retorna os rostos detectados na imagem com suas coordenadas de retângulo e atributos de rosto selecionados. Confira Detecção facial para obter mais detalhes.

// Faces
Console.WriteLine("Faces:");
foreach (var face in results.Faces)
{
    Console.WriteLine($"A {face.Gender} of age {face.Age} at location {face.FaceRectangle.Left}, " +
      $"{face.FaceRectangle.Left}, {face.FaceRectangle.Top + face.FaceRectangle.Width}, " +
      $"{face.FaceRectangle.Top + face.FaceRectangle.Height}");
}
Console.WriteLine();

Detectar conteúdo para adulto, erótico ou violento

O código a seguir imprime a presença detectada de conteúdo para adulto na imagem. Confira Conteúdo para adulto, erótico e violento para obter mais detalhes.

// Adult or racy content, if any.
Console.WriteLine("Adult:");
Console.WriteLine($"Has adult content: {results.Adult.IsAdultContent} with confidence {results.Adult.AdultScore}");
Console.WriteLine($"Has racy content: {results.Adult.IsRacyContent} with confidence {results.Adult.RacyScore}");
Console.WriteLine($"Has gory content: {results.Adult.IsGoryContent} with confidence {results.Adult.GoreScore}");
Console.WriteLine();

Obter esquema de cores da imagem

O código a seguir imprime os atributos de cor detectados na imagem, como as cores dominantes e a cor de destaque. Confira Esquemas de cores para obter mais detalhes.

// Identifies the color scheme.
Console.WriteLine("Color Scheme:");
Console.WriteLine("Is black and white?: " + results.Color.IsBWImg);
Console.WriteLine("Accent color: " + results.Color.AccentColor);
Console.WriteLine("Dominant background color: " + results.Color.DominantColorBackground);
Console.WriteLine("Dominant foreground color: " + results.Color.DominantColorForeground);
Console.WriteLine("Dominant colors: " + string.Join(",", results.Color.DominantColors));
Console.WriteLine();

Obter conteúdo específico do domínio

A Análise de Imagem pode usar modelos especializados para realizar análise adicional em imagens. Confira Conteúdo específico do domínio para obter mais detalhes.

O código a seguir analisa dados sobre celebridades detectados na imagem.

// Celebrities in image, if any.
Console.WriteLine("Celebrities:");
foreach (var category in results.Categories)
{
    if (category.Detail?.Celebrities != null)
    {
        foreach (var celeb in category.Detail.Celebrities)
        {
            Console.WriteLine($"{celeb.Name} with confidence {celeb.Confidence} at location {celeb.FaceRectangle.Left}, " +
              $"{celeb.FaceRectangle.Top}, {celeb.FaceRectangle.Height}, {celeb.FaceRectangle.Width}");
        }
    }
}
Console.WriteLine();

O código a seguir analisa dados sobre pontos de referência detectados na imagem.

// Popular landmarks in image, if any.
Console.WriteLine("Landmarks:");
foreach (var category in results.Categories)
{
    if (category.Detail?.Landmarks != null)
    {
        foreach (var landmark in category.Detail.Landmarks)
        {
            Console.WriteLine($"{landmark.Name} with confidence {landmark.Confidence}");
        }
    }
}
Console.WriteLine();

Obter o tipo de imagem

O código a seguir imprime informações sobre o tipo de imagem —, seja clip-art ou desenho de uma linha.

// Detects the image types.
Console.WriteLine("Image Type:");
Console.WriteLine("Clip Art Type: " + results.ImageType.ClipArtType);
Console.WriteLine("Line Drawing Type: " + results.ImageType.LineDrawingType);
Console.WriteLine();

Executar o aplicativo

Execute o aplicativo clicando no botão Depurar na parte superior da janela do IDE.

Limpar os recursos

Se quiser limpar e remover uma assinatura dos Serviços Cognitivos, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Neste guia de início rápido, você aprendeu a instalar a biblioteca de clientes da Análise de Imagem e a fazer chamadas básicas de análise de imagem. A seguir, saiba mais sobre os recursos da API de Análise.

Use a biblioteca de clientes da Análise de Imagem para analisar uma imagem em busca de marcas, descrição de texto, rostos, conteúdo para adulto, entre outros.

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

Pré-requisitos

  • Uma assinatura do Azure – crie uma gratuitamente

  • Python 3.x

    • A instalação do Python deve incluir o pip. Você pode executar pip --version na linha de comando para verificar se o pip está instalado. Instale a versão mais recente do Python para obter o pip.
  • Depois de obter sua assinatura do Azure, crie um recurso da Pesquisa Visual Computacional no portal do Azure para obter a chave e o ponto de extremidade. Após a implantação, clique em Ir para o recurso.

    • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço de Pesquisa Visual Computacional. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configurando

Instalar a biblioteca de clientes

É possível instalar a biblioteca de clientes com:

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

Instale também a biblioteca Pillow.

pip install pillow

Criar um novo aplicativo Python

Crie um arquivo do Python—quickstart-file.py, por exemplo. Em seguida, abra-o em seu editor ou IDE preferencial e importe as bibliotecas 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

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

Em seguida, crie variáveis para a chave e o ponto de extremidade do Azure do recurso.

subscription_key = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE"
endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE"

Importante

Acesse o portal do Azure. Se o recurso da Pesquisa Visual Computacional criado na seção Pré-requisitos tiver sido implantado com êxito, clique no botão Acessar o Recurso em Próximas Etapas. Encontre a chave e o ponto de extremidade na página da chave e do ponto de extremidade do recurso, em gerenciamento de recursos.

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, considere o uso de uma maneira segura de armazenar e acessar suas credenciais. Por exemplo, o Azure Key Vault.

Modelo de objeto

As classes e as interfaces a seguir lidam com alguns dos principais recursos do SDK da Análise de Imagem para Python.

Nome Descrição
ComputerVisionClientOperationsMixin Essa classe manipula diretamente todas as operações de imagem, como análise de imagem, detecção de texto e geração de miniaturas.
ComputerVisionClient Essa classe é necessária para toda a funcionalidade da Pesquisa Visual Computacional. Você a instancia com suas informações de assinatura e a usa para produzir instâncias de outras classes. Ela implementa ComputerVisionClientOperationsMixin.
VisualFeatureTypes Essa enumeração define os diferentes tipos de análise de imagem que podem ser feitos em uma operação de análise padrão. Especifique um conjunto de valores VisualFeatureTypes dependendo de suas necessidades.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Análise de Imagem para Python:

Autenticar o cliente

Instancie um cliente com o ponto de extremidade e a chave. Crie um objeto CognitiveServicesCredentials com sua chave e use-o com seu ponto de extremidade para criar um objeto ComputerVisionClient.

computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))

Analisar uma imagem

Use o objeto de cliente para analisar os recursos visuais de uma imagem remota. Primeiro, salve uma referência à URL de uma imagem que você deseja analisar.

remote_image_url = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/landmark.jpg"

Dica

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

Obter a descrição da imagem

O código a seguir obtém a lista de legendas geradas para a imagem. Confira Descrever imagens para obter mais detalhes.

'''
Describe an Image - remote
This example describes the contents of an image with the confidence score.
'''
print("===== Describe an image - remote =====")
# Call API
description_results = computervision_client.describe_image(remote_image_url )

# Get the captions (descriptions) from the response, with confidence level
print("Description of remote image: ")
if (len(description_results.captions) == 0):
    print("No description detected.")
else:
    for caption in description_results.captions:
        print("'{}' with confidence {:.2f}%".format(caption.text, caption.confidence * 100))

Obter categoria da imagem

O código a seguir obtém a categoria detectada da imagem. Confira Categorizar imagens para obter detalhes.

'''
Categorize an Image - remote
This example extracts (general) categories from a remote image with a confidence score.
'''
print("===== Categorize an image - remote =====")
# Select the visual feature(s) you want.
remote_image_features = ["categories"]
# Call API with URL and features
categorize_results_remote = computervision_client.analyze_image(remote_image_url , remote_image_features)

# Print results with confidence score
print("Categories from remote image: ")
if (len(categorize_results_remote.categories) == 0):
    print("No categories detected.")
else:
    for category in categorize_results_remote.categories:
        print("'{}' with confidence {:.2f}%".format(category.name, category.score * 100))

Obter marcas da imagem

O código a seguir obtém o conjunto de marcas detectadas na imagem. Confira Marcas de conteúdo para obter mais detalhes.

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

Detectar objetos

O código a seguir detecta objetos comuns na imagem e imprime-os no console. Confira Detecção de objetos para obter mais detalhes.

'''
Detect Objects - remote
This example detects different kinds of objects with bounding boxes in a remote image.
'''
print("===== Detect Objects - remote =====")
# Get URL image with different objects
remote_image_url_objects = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/objects.jpg"
# Call API with URL
detect_objects_results_remote = computervision_client.detect_objects(remote_image_url_objects)

# Print detected objects results with bounding boxes
print("Detecting objects in remote image:")
if len(detect_objects_results_remote.objects) == 0:
    print("No objects detected.")
else:
    for object in detect_objects_results_remote.objects:
        print("object at location {}, {}, {}, {}".format( \
        object.rectangle.x, object.rectangle.x + object.rectangle.w, \
        object.rectangle.y, object.rectangle.y + object.rectangle.h))

Detectar marcas

O código a seguir detecta logotipos e marcas corporativas na imagem e imprime-os no console. Confira Detecção de marca para obter mais detalhes.

'''
Detect Brands - remote
This example detects common brands like logos and puts a bounding box around them.
'''
print("===== Detect Brands - remote =====")
# Get a URL with a brand logo
remote_image_url = "https://docs.microsoft.com/en-us/azure/cognitive-services/computer-vision/images/gray-shirt-logo.jpg"
# Select the visual feature(s) you want
remote_image_features = ["brands"]
# Call API with URL and features
detect_brands_results_remote = computervision_client.analyze_image(remote_image_url, remote_image_features)

print("Detecting brands in remote image: ")
if len(detect_brands_results_remote.brands) == 0:
    print("No brands detected.")
else:
    for brand in detect_brands_results_remote.brands:
        print("'{}' brand detected with confidence {:.1f}% at location {}, {}, {}, {}".format( \
        brand.name, brand.confidence * 100, brand.rectangle.x, brand.rectangle.x + brand.rectangle.w, \
        brand.rectangle.y, brand.rectangle.y + brand.rectangle.h))

Detectar faces

O código a seguir retorna os rostos detectados na imagem com suas coordenadas de retângulo e atributos de rosto selecionados. Confira Detecção facial para obter mais detalhes.

'''
Detect Faces - remote
This example detects faces in a remote image, gets their gender and age, 
and marks them with a bounding box.
'''
print("===== Detect Faces - remote =====")
# Get an image with faces
remote_image_url_faces = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/faces.jpg"
# Select the visual feature(s) you want.
remote_image_features = ["faces"]
# Call the API with remote URL and features
detect_faces_results_remote = computervision_client.analyze_image(remote_image_url_faces, remote_image_features)

# Print the results with gender, age, and bounding box
print("Faces in the remote image: ")
if (len(detect_faces_results_remote.faces) == 0):
    print("No faces detected.")
else:
    for face in detect_faces_results_remote.faces:
        print("'{}' of age {} at location {}, {}, {}, {}".format(face.gender, face.age, \
        face.face_rectangle.left, face.face_rectangle.top, \
        face.face_rectangle.left + face.face_rectangle.width, \
        face.face_rectangle.top + face.face_rectangle.height))

Detectar conteúdo para adulto, erótico ou violento

O código a seguir imprime a presença detectada de conteúdo para adulto na imagem. Confira Conteúdo para adulto, erótico e violento para obter mais detalhes.

'''
Detect Adult or Racy Content - remote
This example detects adult or racy content in a remote image, then prints the adult/racy score.
The score is ranged 0.0 - 1.0 with smaller numbers indicating negative results.
'''
print("===== Detect Adult or Racy Content - remote =====")
# Select the visual feature(s) you want
remote_image_features = ["adult"]
# Call API with URL and features
detect_adult_results_remote = computervision_client.analyze_image(remote_image_url, remote_image_features)

# Print results with adult/racy score
print("Analyzing remote image for adult or racy content ... ")
print("Is adult content: {} with confidence {:.2f}".format(detect_adult_results_remote.adult.is_adult_content, detect_adult_results_remote.adult.adult_score * 100))
print("Has racy content: {} with confidence {:.2f}".format(detect_adult_results_remote.adult.is_racy_content, detect_adult_results_remote.adult.racy_score * 100))

Obter esquema de cores da imagem

O código a seguir imprime os atributos de cor detectados na imagem, como as cores dominantes e a cor de destaque. Confira Esquemas de cores para obter mais detalhes.

'''
Detect Color - remote
This example detects the different aspects of its color scheme in a remote image.
'''
print("===== Detect Color - remote =====")
# Select the feature(s) you want
remote_image_features = ["color"]
# Call API with URL and features
detect_color_results_remote = computervision_client.analyze_image(remote_image_url, remote_image_features)

# Print results of color scheme
print("Getting color scheme of the remote image: ")
print("Is black and white: {}".format(detect_color_results_remote.color.is_bw_img))
print("Accent color: {}".format(detect_color_results_remote.color.accent_color))
print("Dominant background color: {}".format(detect_color_results_remote.color.dominant_color_background))
print("Dominant foreground color: {}".format(detect_color_results_remote.color.dominant_color_foreground))
print("Dominant colors: {}".format(detect_color_results_remote.color.dominant_colors))

Obter conteúdo específico do domínio

A Análise de Imagem pode usar o modelo especializado para realizar a análise adicional em imagens. Confira Conteúdo específico do domínio para obter mais detalhes.

O código a seguir analisa dados sobre celebridades detectados na imagem.

'''
Detect Domain-specific Content - remote
This example detects celebrites and landmarks in remote images.
'''
print("===== Detect Domain-specific Content - remote =====")
# URL of one or more celebrities
remote_image_url_celebs = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/faces.jpg"
# Call API with content type (celebrities) and URL
detect_domain_results_celebs_remote = computervision_client.analyze_image_by_domain("celebrities", remote_image_url_celebs)

# Print detection results with name
print("Celebrities in the remote image:")
if len(detect_domain_results_celebs_remote.result["celebrities"]) == 0:
    print("No celebrities detected.")
else:
    for celeb in detect_domain_results_celebs_remote.result["celebrities"]:
        print(celeb["name"])

O código a seguir analisa dados sobre pontos de referência detectados na imagem.

# Call API with content type (landmarks) and URL
detect_domain_results_landmarks = computervision_client.analyze_image_by_domain("landmarks", remote_image_url)
print()

print("Landmarks in the remote image:")
if len(detect_domain_results_landmarks.result["landmarks"]) == 0:
    print("No landmarks detected.")
else:
    for landmark in detect_domain_results_landmarks.result["landmarks"]:
        print(landmark["name"])

Obter o tipo de imagem

O código a seguir imprime informações sobre o tipo de imagem – seja clip-art ou desenho de linha.

'''
Detect Image Types - remote
This example detects an image's type (clip art/line drawing).
'''
print("===== Detect Image Types - remote =====")
# Get URL of an image with a type
remote_image_url_type = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/type-image.jpg"
# Select visual feature(s) you want
remote_image_features = [VisualFeatureTypes.image_type]
# Call API with URL and features
detect_type_results_remote = computervision_client.analyze_image(remote_image_url_type, remote_image_features)

# Prints type results with degree of accuracy
print("Type of remote image:")
if detect_type_results_remote.image_type.clip_art_type == 0:
    print("Image is not clip art.")
elif detect_type_results_remote.image_type.line_drawing_type == 1:
    print("Image is ambiguously clip art.")
elif detect_type_results_remote.image_type.line_drawing_type == 2:
    print("Image is normal clip art.")
else:
    print("Image is good clip art.")

if detect_type_results_remote.image_type.line_drawing_type == 0:
    print("Image is not a line drawing.")
else:
    print("Image is a line drawing")

Executar o aplicativo

Execute o aplicativo com o comando python no seu arquivo de início rápido.

python quickstart-file.py

Limpar os recursos

Se quiser limpar e remover uma assinatura dos Serviços Cognitivos, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Neste guia de início rápido, você aprendeu a instalar a biblioteca de clientes da Análise de Imagem e a fazer chamadas básicas de análise de imagem. A seguir, saiba mais sobre os recursos da API de Análise.

Use a biblioteca de clientes da Análise de Imagem para analisar uma imagem em busca de marcas, descrição de texto, rostos, conteúdo para adulto, entre outros.

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

Pré-requisitos

  • Uma assinatura do Azure – crie uma gratuitamente
  • A versão atual do JDK (Java Development Kit)
  • A ferramenta de build Gradle ou outro gerenciador de dependência.
  • Depois de obter sua assinatura do Azure, crie um recurso da Pesquisa Visual Computacional no portal do Azure para obter a chave e o ponto de extremidade. Após a implantação, clique em Ir para o recurso.
    • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço de Pesquisa Visual Computacional. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configurando

Criar um novo projeto Gradle

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando gradle init em seu diretório de trabalho. Esse comando criará arquivos de build essenciais para o Gradle, incluindo o build.gradle.kts, que é usado no runtime para criar e configurar seu aplicativo.

gradle init --type basic

Quando solicitado a escolher uma DSL, escolha Kotlin.

Instalar a biblioteca de clientes

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

Localize o build.gradle.kts e abra-o com seu IDE ou editor de texto preferencial. Depois copie nessa configuração de build a seguir. Esta configuração define o projeto como um aplicativo Java cujo ponto de entrada é a classe ImageAnalysisQuickstart. Ela importa a biblioteca da Pesquisa Visual Computacional.

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

Criar um arquivo Java

Em seu diretório de trabalho, execute o comando a seguir 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-a no editor ou IDE de sua preferência e adicione as seguintes instruções import:

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;

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

Defina a classe ImageAnalysisQuickstart.

public class ImageAnalysisQuickstart {
}

Na classe ImageAnalysisQuickstart, crie variáveis para a chave e o ponto de extremidade do recurso.

static String subscriptionKey = "PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE";
static String endpoint = "PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE";

Importante

Acesse o portal do Azure. Se o recurso da Pesquisa Visual Computacional criado na seção Pré-requisitos tiver sido implantado com êxito, clique no botão Acessar o Recurso em Próximas Etapas. Encontre a chave e o ponto de extremidade na página da chave e do ponto de extremidade do recurso, em gerenciamento de recursos.

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, considere o uso de uma maneira segura de armazenar e acessar suas credenciais. Confira o artigo segurança de Serviços Cognitivos para obter mais informações.

No método main do aplicativo, adicione chamadas para os métodos usados neste guia de início rápido. Você os definirá mais tarde.

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(subscriptionKey, endpoint); 

    // Analyze local and remote images
    AnalyzeLocalImage(compVisClient);

}

Modelo de objeto

As classes e as interfaces a seguir lidam com alguns dos principais recursos do SDK da Análise de Imagem para Java.

Nome Descrição
ComputerVisionClient Essa classe é necessária para toda a funcionalidade da Pesquisa Visual Computacional. Você a instancia com suas informações de assinatura e a usa para produzir instâncias de outras classes.
ComputerVision Essa classe é proveniente do objeto de cliente e manipula diretamente todas as operações de imagem, como análise de imagem, detecção de texto e geração de miniaturas.
VisualFeatureTypes Essa enumeração define os diferentes tipos de análise de imagem que podem ser feitos em uma operação de análise padrão. Especifique um conjunto de valores VisualFeatureTypes dependendo de suas necessidades.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Análise de Imagem para Java:

Autenticar o cliente

Em um novo método, crie uma instância do objeto ComputerVisionClient com o ponto de extremidade e a chave.

public static ComputerVisionClient Authenticate(String subscriptionKey, String endpoint){
    return ComputerVisionManager.authenticate(subscriptionKey).withEndpoint(endpoint);
}

Analisar uma imagem

O código a seguir define um método AnalyzeLocalImage, que usa o objeto de cliente para analisar uma imagem local e imprimir os resultados. O método retorna uma descrição de texto, categorização, lista de marcas, rostos detectados, sinalizadores de conteúdo para adulto, cores principais e tipo de imagem.

Dica

Você também pode analisar uma imagem remota usando sua URL. Confira os métodos de ComputerVision, como AnalyzeImage. Ou veja o código de exemplo no GitHub para ver cenários que envolvem imagens remotas.

Configurar imagem de teste

Primeiro, crie uma pasta resources/ na pasta src/main/ do seu projeto e adicione uma imagem que você gostaria de analisar. Em seguida, adicione a seguinte definição de método à sua classe ImageAnalysisQuickstart. Altere o valor de pathToLocalImage para corresponder ao arquivo de imagem.

public static void AnalyzeLocalImage(ComputerVisionClient compVisClient) {
    /*
     * Analyze a local image:
     *
     * Set a string variable equal to the path of a local image. The image path
     * below is a relative path.
     */
    String pathToLocalImage = "src\\main\\resources\\myImage.png";

Especificar recursos visuais

Em seguida, especifique quais recursos visuais você gostaria de extrair em sua análise. Confira a enumeração VisualFeatureTypes para obter uma lista completa.

// This list defines the features to be extracted from the image.
List<VisualFeatureTypes> featuresToExtractFromLocalImage = new ArrayList<>();
featuresToExtractFromLocalImage.add(VisualFeatureTypes.DESCRIPTION);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.CATEGORIES);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.TAGS);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.FACES);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.OBJECTS);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.BRANDS);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.ADULT);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.COLOR);
featuresToExtractFromLocalImage.add(VisualFeatureTypes.IMAGE_TYPE);

Analisar

Esse bloco imprime resultados detalhados no console para cada escopo de análise de imagem. O método analyzeImageInStream retorna um objeto ImageAnalysis que contém todas as informações extraídas.

try {
    // Need a byte array for analyzing a local image.
    File rawImage = new File(pathToLocalImage);
    byte[] imageByteArray = Files.readAllBytes(rawImage.toPath());

    // Call the Computer Vision service and tell it to analyze the loaded image.
    ImageAnalysis analysis = compVisClient.computerVision().analyzeImageInStream().withImage(imageByteArray)
            .withVisualFeatures(featuresToExtractFromLocalImage).execute();

As seções a seguir mostram como analisar essas informações detalhadamente.

Obter a descrição da imagem

O código a seguir obtém a lista de legendas geradas para a imagem. Para obter mais informações, confira Descrever imagens.

// Display image captions and confidence values.
System.out.println("\nCaptions: ");
for (ImageCaption caption : analysis.description().captions()) {
    System.out.printf("\'%s\' with confidence %f\n", caption.text(), caption.confidence());
}

Obter categoria da imagem

O código a seguir obtém a categoria detectada da imagem. Para obter mais informações, consulte Categorizar imagens.

// Display image category names and confidence values.
System.out.println("\nCategories: ");
for (Category category : analysis.categories()) {
    System.out.printf("\'%s\' with confidence %f\n", category.name(), category.score());
}

Obter marcas da imagem

O código a seguir obtém o conjunto de marcas detectadas na imagem. Para obter mais informações, consulte Marcas de conteúdo.

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

Detectar faces

O código a seguir retorna os rostos detectados na imagem com suas coordenadas de retângulo e atributos de rosto selecionados. Para obter mais informações, consulte Detecção facial.

// Display any faces found in the image and their location.
System.out.println("\nFaces: ");
for (FaceDescription face : analysis.faces()) {
    System.out.printf("\'%s\' of age %d at location (%d, %d), (%d, %d)\n", face.gender(), face.age(),
            face.faceRectangle().left(), face.faceRectangle().top(),
            face.faceRectangle().left() + face.faceRectangle().width(),
            face.faceRectangle().top() + face.faceRectangle().height());
}

Detectar objetos

O código a seguir retorna os objetos detectados na imagem com suas coordenadas. Para obter mais informações, confira Detecção de objetos.

// Display any objects found in the image.
System.out.println("\nObjects: ");
for ( DetectedObject object : analysis.objects()) {
    System.out.printf("Object \'%s\' detected at location (%d, %d)\n", object.objectProperty(),
            object.rectangle().x(), object.rectangle().y());
}

Detectar marcas

O código a seguir retorna os logotipos de marcas detectados na imagem com suas coordenadas. Para obter mais informações, confira Detecção de objetos.

// Display any brands found in the image.
System.out.println("\nBrands: ");
for ( DetectedBrand brand : analysis.brands()) {
    System.out.printf("Brand \'%s\' detected at location (%d, %d)\n", brand.name(),
            brand.rectangle().x(), brand.rectangle().y());
}

Detectar conteúdo para adulto, erótico ou violento

O código a seguir imprime a presença detectada de conteúdo para adulto na imagem. Para obter mais informações, confira Conteúdo para adulto, erótico e violento.

// Display whether any adult/racy/gory content was detected and the confidence
// values.
System.out.println("\nAdult: ");
System.out.printf("Is adult content: %b with confidence %f\n", analysis.adult().isAdultContent(),
        analysis.adult().adultScore());
System.out.printf("Has racy content: %b with confidence %f\n", analysis.adult().isRacyContent(),
        analysis.adult().racyScore());
System.out.printf("Has gory content: %b with confidence %f\n", analysis.adult().isGoryContent(),
        analysis.adult().goreScore());

Obter esquema de cores da imagem

O código a seguir imprime os atributos de cor detectados na imagem, como as cores dominantes e a cor de destaque. Para obter mais informações, consulte Esquemas de cores.

// Display the image color scheme.
System.out.println("\nColor scheme: ");
System.out.println("Is black and white: " + analysis.color().isBWImg());
System.out.println("Accent color: " + analysis.color().accentColor());
System.out.println("Dominant background color: " + analysis.color().dominantColorBackground());
System.out.println("Dominant foreground color: " + analysis.color().dominantColorForeground());
System.out.println("Dominant colors: " + String.join(", ", analysis.color().dominantColors()));

Obter conteúdo específico do domínio

A Análise de Imagem pode usar o modelo especializado para realizar a análise adicional em imagens. Para obter mais informações, confira Conteúdo específico do domínio.

O código a seguir analisa dados sobre celebridades detectados na imagem.

// Display any celebrities detected in the image and their locations.
System.out.println("\nCelebrities: ");
for (Category category : analysis.categories()) {
    if (category.detail() != null && category.detail().celebrities() != null) {
        for (CelebritiesModel celeb : category.detail().celebrities()) {
            System.out.printf("\'%s\' with confidence %f at location (%d, %d), (%d, %d)\n", celeb.name(),
                    celeb.confidence(), celeb.faceRectangle().left(), celeb.faceRectangle().top(),
                    celeb.faceRectangle().left() + celeb.faceRectangle().width(),
                    celeb.faceRectangle().top() + celeb.faceRectangle().height());
        }
    }
}

O código a seguir analisa dados sobre pontos de referência detectados na imagem.

// Display any landmarks detected in the image and their locations.
System.out.println("\nLandmarks: ");
for (Category category : analysis.categories()) {
    if (category.detail() != null && category.detail().landmarks() != null) {
        for (LandmarksModel landmark : category.detail().landmarks()) {
            System.out.printf("\'%s\' with confidence %f\n", landmark.name(), landmark.confidence());
        }
    }
}

Obter o tipo de imagem

O código a seguir imprime informações sobre o tipo de imagem – seja clip-art ou desenho de linha.

// Display what type of clip art or line drawing the image is.
System.out.println("\nImage type:");
System.out.println("Clip art type: " + analysis.imageType().clipArtType());
System.out.println("Line drawing type: " + analysis.imageType().lineDrawingType());

Fechar o método

Conclua o bloco try/catch e feche o método.

    }

    catch (Exception e) {
        System.out.println(e.getMessage());
        e.printStackTrace();
    }
}

Executar o aplicativo

É possível criar o aplicativo com:

gradle build

Execute o aplicativo com o comando gradle run:

gradle run

Limpar os recursos

Se quiser limpar e remover uma assinatura dos Serviços Cognitivos, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Neste guia de início rápido, você aprendeu a instalar a biblioteca de clientes da Análise de Imagem e a fazer chamadas básicas de análise de imagem. A seguir, saiba mais sobre os recursos da API de Análise.

Use a biblioteca de clientes da Análise de Imagem para analisar uma imagem em busca de marcas, descrição de texto, rostos, conteúdo para adulto, entre outros.

Documentação de referência | Código-fonte da biblioteca | Pacote (npm) | Exemplos

Pré-requisitos

  • Uma assinatura do Azure – crie uma gratuitamente
  • A versão atual do Node.js
  • Depois de obter sua assinatura do Azure, crie um recurso da Pesquisa Visual Computacional no portal do Azure para obter a chave e o ponto de extremidade. Após a implantação, clique em Ir para o recurso.
    • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço de Pesquisa Visual Computacional. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configurando

Criar um novo aplicativo do Node.js

Em uma janela de console (como cmd, PowerShell ou Bash), crie um novo diretório para seu aplicativo e navegue até ele.

mkdir myapp && cd myapp

Execute o comando npm init para criar um aplicativo do Node com um arquivo package.json.

npm init

Instalar a biblioteca de clientes

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

npm install @azure/cognitiveservices-computervision

Instale também o módulo assíncrono:

npm install async

O arquivo package.json do seu aplicativo será atualizado com as dependências.

Crie um novo arquivo, index.js, e abra-o em um editor de texto. Adicione as seguintes instruções de importação ao arquivo.

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

Dica

Deseja exibir todo o arquivo de código do início rápido de uma vez? Você pode encontrá-lo no GitHub, que contém os exemplos de código neste início rápido.

Crie variáveis para a chave e o ponto de extremidade do Azure do recurso.

/**
 * AUTHENTICATE
 * This single client is used for all examples.
 */
const key = 'PASTE_YOUR_COMPUTER_VISION_SUBSCRIPTION_KEY_HERE';
const endpoint = 'PASTE_YOUR_COMPUTER_VISION_ENDPOINT_HERE';

Importante

Acesse o portal do Azure. Se o recurso da Pesquisa Visual Computacional criado na seção Pré-requisitos tiver sido implantado com êxito, clique no botão Acessar o Recurso em Próximas Etapas. Encontre a chave e o ponto de extremidade na página da chave e do ponto de extremidade do recurso, em gerenciamento de recursos.

Lembre-se de remover a chave do seu código quando terminar e nunca poste-a publicamente. Para produção, considere o uso de uma maneira segura de armazenar e acessar suas credenciais. Confira o artigo segurança de Serviços Cognitivos para obter mais informações.

Modelo de objeto

As classes e as interfaces a seguir lidam com alguns dos principais recursos do SDK da Análise de Imagem para Node.js.

Nome Descrição
ComputerVisionClient Essa classe é necessária para toda a funcionalidade da Pesquisa Visual Computacional. Você cria uma instância delas com suas informações de assinatura e usa-a para fazer a maioria das operações de imagem.
VisualFeatureTypes Essa enumeração define os diferentes tipos de análise de imagem que podem ser feitos em uma operação de análise padrão. Especifique um conjunto de valores VisualFeatureTypes dependendo de suas necessidades.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Análise de Imagem para Node.js:

Autenticar o cliente

Instancie um cliente com o ponto de extremidade e a chave. Crie um objeto ApiKeyCredentials com sua chave e ponto de extremidade e use-o para criar um objeto ComputerVisionClient.

const computerVisionClient = new ComputerVisionClient(
  new ApiKeyCredentials({ inHeader: { 'Ocp-Apim-Subscription-Key': key } }), endpoint);

Em seguida, defina uma função computerVision e declare uma série assíncrona com a função principal e a função de retorno de chamada. Você adicionará o código de início rápido à função principal e chamará computerVision na parte inferior do script. O restante do código neste guia de início rápido vai dentro da função computerVision.

function computerVision() {
  async.series([
    async function () {

    },
    function () {
      return new Promise((resolve) => {
        resolve();
      })
    }
  ], (err) => {
    throw (err);
  });
}

computerVision();

Analisar uma imagem

O código nesta seção analisa as imagens remotas para extrair vários recursos visuais. Você pode executar essas operações como parte do método analyzeImage do objeto cliente ou chamá-las usando métodos individuais. Confira a documentação de referência para obter detalhes.

Observação

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

Obter a descrição da imagem

O código a seguir obtém a lista de legendas geradas para a imagem. Confira Descrever imagens para obter mais detalhes.

Primeiro, defina a URL de uma imagem a ser analisada:

const describeURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/celebrities.jpg';

Em seguida, adicione o código a seguir para obter a descrição da imagem e imprimi-la no console.

// Analyze URL image
console.log('Analyzing URL image to describe...', describeURL.split('/').pop());
const caption = (await computerVisionClient.describeImage(describeURL)).captions[0];
console.log(`This may be ${caption.text} (${caption.confidence.toFixed(2)} confidence)`);

Obter categoria da imagem

O código a seguir obtém a categoria detectada da imagem. Confira Categorizar imagens para obter detalhes.

const categoryURLImage = 'https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png';

// Analyze URL image
console.log('Analyzing category in image...', categoryURLImage.split('/').pop());
const categories = (await computerVisionClient.analyzeImage(categoryURLImage)).categories;
console.log(`Categories: ${formatCategories(categories)}`);

Defina a função auxiliar formatCategories:

// Formats the image categories
function formatCategories(categories) {
  categories.sort((a, b) => b.score - a.score);
  return categories.map(cat => `${cat.name} (${cat.score.toFixed(2)})`).join(', ');
}

Obter marcas da imagem

O código a seguir obtém o conjunto de marcas detectadas na imagem. Confira Marcas de conteúdo para obter mais detalhes.

console.log('-------------------------------------------------');
console.log('DETECT TAGS');
console.log();

// Image of different kind of dog.
const tagsURL = 'https://moderatorsampleimages.blob.core.windows.net/samples/sample16.png';

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

Defina a função auxiliar formatTags:

// Format tags for display
function formatTags(tags) {
  return tags.map(tag => (`${tag.name} (${tag.confidence.toFixed(2)})`)).join(', ');
}

Detectar objetos

O código a seguir detecta objetos comuns na imagem e imprime-os no console. Confira Detecção de objetos para obter mais detalhes.

// Image of a dog
const objectURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-node-sdk-samples/master/Data/image.jpg';

// Analyze a URL image
console.log('Analyzing objects in image...', objectURL.split('/').pop());
const objects = (await computerVisionClient.analyzeImage(objectURL, { visualFeatures: ['Objects'] })).objects;
console.log();

// Print objects bounding box and confidence
if (objects.length) {
  console.log(`${objects.length} object${objects.length == 1 ? '' : 's'} found:`);
  for (const obj of objects) { console.log(`    ${obj.object} (${obj.confidence.toFixed(2)}) at ${formatRectObjects(obj.rectangle)}`); }
} else { console.log('No objects found.'); }

Defina a função auxiliar formatRectObjects para retornar as coordenadas superior, esquerda, inferior e direita, juntamente com a largura e a altura.

// Formats the bounding box
function formatRectObjects(rect) {
  return `top=${rect.y}`.padEnd(10) + `left=${rect.x}`.padEnd(10) + `bottom=${rect.y + rect.h}`.padEnd(12)
    + `right=${rect.x + rect.w}`.padEnd(10) + `(${rect.w}x${rect.h})`;
}

Detectar marcas

O código a seguir detecta logotipos e marcas corporativas na imagem e imprime-os no console. Confira Detecção de marca para obter mais detalhes.

const brandURLImage = 'https://docs.microsoft.com/en-us/azure/cognitive-services/computer-vision/images/red-shirt-logo.jpg';

// Analyze URL image
console.log('Analyzing brands in image...', brandURLImage.split('/').pop());
const brands = (await computerVisionClient.analyzeImage(brandURLImage, { visualFeatures: ['Brands'] })).brands;

// Print the brands found
if (brands.length) {
  console.log(`${brands.length} brand${brands.length != 1 ? 's' : ''} found:`);
  for (const brand of brands) {
    console.log(`    ${brand.name} (${brand.confidence.toFixed(2)} confidence)`);
  }
} else { console.log(`No brands found.`); }

Detectar faces

O código a seguir retorna os rostos detectados na imagem com suas coordenadas de retângulo e atributos de rosto selecionados. Confira Detecção facial para obter mais detalhes.

const facesImageURL = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/faces.jpg';

// Analyze URL image.
console.log('Analyzing faces in image...', facesImageURL.split('/').pop());
// Get the visual feature for 'Faces' only.
const faces = (await computerVisionClient.analyzeImage(facesImageURL, { visualFeatures: ['Faces'] })).faces;

// Print the bounding box, gender, and age from the faces.
if (faces.length) {
  console.log(`${faces.length} face${faces.length == 1 ? '' : 's'} found:`);
  for (const face of faces) {
    console.log(`    Gender: ${face.gender}`.padEnd(20)
      + ` Age: ${face.age}`.padEnd(10) + `at ${formatRectFaces(face.faceRectangle)}`);
  }
} else { console.log('No faces found.'); }

Defina a função auxiliar formatRectFaces:

// Formats the bounding box
function formatRectFaces(rect) {
  return `top=${rect.top}`.padEnd(10) + `left=${rect.left}`.padEnd(10) + `bottom=${rect.top + rect.height}`.padEnd(12)
    + `right=${rect.left + rect.width}`.padEnd(10) + `(${rect.width}x${rect.height})`;
}

Detectar conteúdo para adulto, erótico ou violento

O código a seguir imprime a presença detectada de conteúdo para adulto na imagem. Confira Conteúdo para adulto, erótico e violento para obter mais detalhes.

Defina a URL da imagem que será usada:

// The URL image and local images are not racy/adult. 
// Try your own racy/adult images for a more effective result.
const adultURLImage = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/celebrities.jpg';

Depois, adicione o código a seguir para detectar conteúdo para adulto e imprimir os resultados no console.

// Function to confirm racy or not
const isIt = flag => flag ? 'is' : "isn't";

// Analyze URL image
console.log('Analyzing image for racy/adult content...', adultURLImage.split('/').pop());
const adult = (await computerVisionClient.analyzeImage(adultURLImage, {
  visualFeatures: ['Adult']
})).adult;
console.log(`This probably ${isIt(adult.isAdultContent)} adult content (${adult.adultScore.toFixed(4)} score)`);
console.log(`This probably ${isIt(adult.isRacyContent)} racy content (${adult.racyScore.toFixed(4)} score)`);

Obter esquema de cores da imagem

O código a seguir imprime os atributos de cor detectados na imagem, como as cores dominantes e a cor de destaque. Confira Esquemas de cores para obter mais detalhes.

const colorURLImage = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/celebrities.jpg';

// Analyze URL image
console.log('Analyzing image for color scheme...', colorURLImage.split('/').pop());
console.log();
const color = (await computerVisionClient.analyzeImage(colorURLImage, { visualFeatures: ['Color'] })).color;
printColorScheme(color);

Defina a função auxiliar printColorScheme para imprimir os detalhes do esquema de cores no console.

// Print a detected color scheme
function printColorScheme(colors) {
  console.log(`Image is in ${colors.isBwImg ? 'black and white' : 'color'}`);
  console.log(`Dominant colors: ${colors.dominantColors.join(', ')}`);
  console.log(`Dominant foreground color: ${colors.dominantColorForeground}`);
  console.log(`Dominant background color: ${colors.dominantColorBackground}`);
  console.log(`Suggested accent color: #${colors.accentColor}`);
}

Obter conteúdo específico do domínio

A Análise de Imagem pode usar o modelo especializado para realizar a análise adicional em imagens. Confira Conteúdo específico do domínio para obter mais detalhes.

Primeiro, defina a URL de uma imagem a ser analisada:

const domainURLImage = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-sample-data-files/master/ComputerVision/Images/landmark.jpg';

O código a seguir analisa dados sobre pontos de referência detectados na imagem.

// Analyze URL image
console.log('Analyzing image for landmarks...', domainURLImage.split('/').pop());
const domain = (await computerVisionClient.analyzeImageByDomain('landmarks', domainURLImage)).result.landmarks;

// Prints domain-specific, recognized objects
if (domain.length) {
  console.log(`${domain.length} ${domain.length == 1 ? 'landmark' : 'landmarks'} found:`);
  for (const obj of domain) {
    console.log(`    ${obj.name}`.padEnd(20) + `(${obj.confidence.toFixed(2)} confidence)`.padEnd(20) + `${formatRectDomain(obj.faceRectangle)}`);
  }
} else {
  console.log('No landmarks found.');
}

Defina a função auxiliar formatRectDomain para analisar os dados de localização sobre os pontos de referência detectados.

// Formats bounding box
function formatRectDomain(rect) {
  if (!rect) return '';
  return `top=${rect.top}`.padEnd(10) + `left=${rect.left}`.padEnd(10) + `bottom=${rect.top + rect.height}`.padEnd(12) +
    `right=${rect.left + rect.width}`.padEnd(10) + `(${rect.width}x${rect.height})`;
}

Obter o tipo de imagem

O código a seguir imprime informações sobre o tipo de imagem – seja clip-art ou desenho de linha.

const typeURLImage = 'https://raw.githubusercontent.com/Azure-Samples/cognitive-services-python-sdk-samples/master/samples/vision/images/make_things_happen.jpg';

// Analyze URL image
console.log('Analyzing type in image...', typeURLImage.split('/').pop());
const types = (await computerVisionClient.analyzeImage(typeURLImage, { visualFeatures: ['ImageType'] })).imageType;
console.log(`Image appears to be ${describeType(types)}`);

Defina a função auxiliar describeType:

function describeType(imageType) {
  if (imageType.clipArtType && imageType.clipArtType > imageType.lineDrawingType) return 'clip art';
  if (imageType.lineDrawingType && imageType.clipArtType < imageType.lineDrawingType) return 'a line drawing';
  return 'a photograph';
}

Executar o aplicativo

Execute o aplicativo com o comando node no seu arquivo de início rápido.

node index.js

Limpar os recursos

Se quiser limpar e remover uma assinatura dos Serviços Cognitivos, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Neste guia de início rápido, você aprendeu a instalar a biblioteca de clientes da Análise de Imagem e a fazer chamadas básicas de análise de imagem. A seguir, saiba mais sobre os recursos da API de Análise.

Use a biblioteca de clientes da Análise de Imagem para analisar uma imagem em busca de marcas, descrição de texto, rostos, conteúdo para adulto, entre outros.

Documentação de referência | Código-fonte da biblioteca | Pacote

Pré-requisitos

  • Uma assinatura do Azure – crie uma gratuitamente
  • A versão mais recente do Go
  • Depois de obter sua assinatura do Azure, crie um recurso da Pesquisa Visual Computacional no portal do Azure para obter a chave e o ponto de extremidade. Após a implantação, clique em Ir para o recurso.
    • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço de Pesquisa Visual Computacional. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.

Configurando

Criar um diretório do projeto Go

Em uma janela de console (cmd, PowerShell, Terminal, Bash), crie um novo workspace para seu projeto do Go, chamado my-app, e navegue até ele.

mkdir -p my-app/{src, bin, pkg}  
cd my-app

Seu workspace conterá três pastas:

  • src – Esse diretório terá o código-fonte e os pacotes. Todos os pacotes instalados com o comando go get residirão nesse diretório.
  • pkg – Esse diretório terá os objetos de pacote Go compilados. Todos esses arquivos têm uma extensão .a.
  • bin – Esse diretório terá os arquivos executáveis binários que são criados quando você executa o go install.

Dica

Para saber mais sobre a estrutura de um workspace Go, consulte a documentação da linguagem Go. Este guia inclui informações para configurar $GOPATH e $GOROOT.

Instalar a biblioteca de clientes para Go

Em seguida, instale a biblioteca de clientes para Go:

go get -u https://github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v2.1/computervision

Ou se você usar o DEP, no repositório, execute:

dep ensure -add https://github.com/Azure/azure-sdk-for-go/tree/master/services/cognitiveservices/v2.1/computervision

Criar um aplicativo Go

Em seguida, crie um arquivo no diretório src chamado sample-app.go:

cd src
touch sample-app.go

Abra sample-app.go em seu IDE ou editor de texto preferido. Em seguida, adicione o nome do pacote e importe as seguintes bibliotecas:

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.0/computervision"
    "github.com/Azure/go-autorest/autorest"
    "io"
    "log"
    "os"
    "strings"
    "time"
)

Além disso, declare um contexto na raiz do seu script. Você precisará deste objeto para executar a maioria das chamadas de função da Análise de Imagem:

// Declare global so don't have to pass it to all of the tasks.
var computerVisionContext context.Context

Em seguida, você começará a adicionar o código para realizar diferentes operações de Pesquisa Visual Computacional.

Modelo de objeto

As classes e as interfaces a seguir lidam com alguns dos principais recursos do SDK da Análise de Imagem para Go.

Nome Descrição
BaseClient Essa classe é necessária para todas as funcionalidades de Pesquisa Visual Computacional, como análise de imagem e leitura de texto. Você cria uma instância delas com suas informações de assinatura e usa-a para fazer a maioria das operações de imagem.
ImageAnalysis Esse tipo contém os resultados de uma chamada de função AnalyzeImage. Há tipos semelhantes para cada uma das funções específicas da categoria.
VisualFeatureTypes Esse tipo define os diferentes tipos de análise de imagem que podem ser feitos em uma operação de análise padrão. Especifique um conjunto de valores VisualFeatureTypes dependendo de suas necessidades.

Exemplos de código

Estes snippets de código mostram como realizar as seguintes tarefas com a biblioteca de clientes da Análise de Imagem para Go:

Autenticar o cliente

Observação

Esta etapa pressupõe que você já criou variáveis de ambiente para a chave e o ponto de extremidade da Pesquisa Visual Computacional, denominados COMPUTER_VISION_SUBSCRIPTION_KEY e COMPUTER_VISION_ENDPOINT, respectivamente.

Crie uma função main e adicione o código a seguir a ela para criar uma instância de um cliente com o ponto de extremidade e a chave.

/*  
 * Configure the Computer Vision client
 */
computerVisionClient := computervision.New(endpointURL);
computerVisionClient.Authorizer = autorest.NewCognitiveServicesAuthorizer(computerVisionKey)

computerVisionContext = context.Background()
/*
 * END - Configure the Computer Vision client
 */

Analisar uma imagem

O código a seguir usa o objeto de cliente para analisar uma imagem remota e imprimir os resultados para o console. Você pode obter uma descrição de texto, categorização, lista de marcas, objetos detectados, rostos detectados, sinalizadores de conteúdo para adulto, cores principais e tipo de imagem.

Configurar imagem de teste

Primeiro, salve uma referência à URL da imagem que você deseja analisar. Coloque isso dentro de sua função main.

landmarkImageURL := "https://github.com/Azure-Samples/cognitive-services-sample-data-files/raw/master/ComputerVision/Images/landmark.jpg"

Dica

Você também pode analisar uma imagem local. Confira os métodos de BaseClient, como AnalyzeImageInStream. Ou veja o código de exemplo no GitHub para obter cenários que envolvam imagens locais.

Especificar recursos visuais

As chamadas de função a seguir extraem recursos visuais diferentes da imagem de exemplo. Você definirá essas funções nas seções a seguir.

// Analyze features of an image, remote
DescribeRemoteImage(computerVisionClient, landmarkImageURL)
CategorizeRemoteImage(computerVisionClient, landmarkImageURL)
TagRemoteImage(computerVisionClient, landmarkImageURL)
DetectFacesRemoteImage(computerVisionClient, facesImageURL)
DetectObjectsRemoteImage(computerVisionClient, objectsImageURL)
DetectBrandsRemoteImage(computerVisionClient, brandsImageURL)
DetectAdultOrRacyContentRemoteImage(computerVisionClient, adultRacyImageURL)
DetectColorSchemeRemoteImage(computerVisionClient, brandsImageURL)
DetectDomainSpecificContentRemoteImage(computerVisionClient, landmarkImageURL)
DetectImageTypesRemoteImage(computerVisionClient, detectTypeImageURL)
GenerateThumbnailRemoteImage(computerVisionClient, adultRacyImageURL)

Obter a descrição da imagem

A função a seguir obtém a lista de legendas geradas para a imagem. Para obter mais informações sobre a descrição da imagem, consulte Descrever imagens.

func DescribeRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DESCRIBE IMAGE - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    maxNumberDescriptionCandidates := new(int32)
    *maxNumberDescriptionCandidates = 1

    remoteImageDescription, err := client.DescribeImage(
            computerVisionContext,
            remoteImage,
            maxNumberDescriptionCandidates,
            "") // language
        if err != nil { log.Fatal(err) }

    fmt.Println("Captions from remote image: ")
    if len(*remoteImageDescription.Captions) == 0 {
        fmt.Println("No captions detected.")
    } else {
        for _, caption := range *remoteImageDescription.Captions {
            fmt.Printf("'%v' with confidence %.2f%%\n", *caption.Text, *caption.Confidence * 100)
        }
    }
    fmt.Println()
}

Obter categoria da imagem

A função a seguir obtém a categoria detectada da imagem. Para obter mais informações, consulte Categorizar imagens.

func CategorizeRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("CATEGORIZE IMAGE - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesCategories}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "")
    if err != nil { log.Fatal(err) }

    fmt.Println("Categories from remote image: ")
    if len(*imageAnalysis.Categories) == 0 {
        fmt.Println("No categories detected.")
    } else {
        for _, category := range *imageAnalysis.Categories {
            fmt.Printf("'%v' with confidence %.2f%%\n", *category.Name, *category.Score * 100)
        }
    }
    fmt.Println()
}

Obter marcas da imagem

A função a seguir obtém o conjunto de marcas detectadas na imagem. Para obter mais informações, consulte Marcas de conteúdo.

func TagRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("TAG IMAGE - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    remoteImageTags, err := client.TagImage(
            computerVisionContext,
            remoteImage,
            "")
    if err != nil { log.Fatal(err) }

    fmt.Println("Tags in the remote image: ")
    if len(*remoteImageTags.Tags) == 0 {
        fmt.Println("No tags detected.")
    } else {
        for _, tag := range *remoteImageTags.Tags {
            fmt.Printf("'%v' with confidence %.2f%%\n", *tag.Name, *tag.Confidence * 100)
        }
    }
    fmt.Println()
}

Detectar objetos

A função a seguir detecta objetos comuns na imagem e imprime-os no console. Para obter mais informações, confira Detecção de objetos.

func DetectObjectsRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT OBJECTS - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    imageAnalysis, err := client.DetectObjects(
            computerVisionContext,
            remoteImage,
    )
    if err != nil { log.Fatal(err) }

    fmt.Println("Detecting objects in remote image: ")
    if len(*imageAnalysis.Objects) == 0 {
        fmt.Println("No objects detected.")
    } else {
        // Print the objects found with confidence level and bounding box locations.
        for _, object := range *imageAnalysis.Objects {
            fmt.Printf("'%v' with confidence %.2f%% at location (%v, %v), (%v, %v)\n",
                *object.Object, *object.Confidence * 100,
                *object.Rectangle.X, *object.Rectangle.X + *object.Rectangle.W,
                *object.Rectangle.Y, *object.Rectangle.Y + *object.Rectangle.H)
        }
    }
    fmt.Println()
}

Detectar marcas

O código a seguir detecta logotipos e marcas corporativas na imagem e imprime-os no console. Para obter mais informações, Detecção de objetos.

Primeiro, declare uma referência a uma nova imagem dentro de sua função main.

brandsImageURL := "https://docs.microsoft.com/en-us/azure/cognitive-services/computer-vision/images/gray-shirt-logo.jpg"

O código a seguir define a função de detecção de marca.

func DetectBrandsRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT BRANDS - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the kinds of features you want returned.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesBrands}

    imageAnalysis, err := client.AnalyzeImage(
        computerVisionContext,
        remoteImage,
        features,
        []computervision.Details{},
        "en")
    if err != nil { log.Fatal(err) }

    fmt.Println("Detecting brands in remote image: ")
    if len(*imageAnalysis.Brands) == 0 {
        fmt.Println("No brands detected.")
    } else {
        // Get bounding box around the brand and confidence level it's correctly identified.
        for _, brand := range *imageAnalysis.Brands {
            fmt.Printf("'%v' with confidence %.2f%% at location (%v, %v), (%v, %v)\n",
                *brand.Name, *brand.Confidence * 100,
                *brand.Rectangle.X, *brand.Rectangle.X + *brand.Rectangle.W,
                *brand.Rectangle.Y, *brand.Rectangle.Y + *brand.Rectangle.H)
        }
    }
    fmt.Println()
}

Detectar faces

A função a seguir retorna os rostos detectados na imagem com suas coordenadas de retângulo e alguns atributos de rosto. Para obter mais informações, consulte Detecção facial.

func DetectFacesRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT FACES - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the features you want returned with the API call.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesFaces}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "")
        if err != nil { log.Fatal(err) }

    fmt.Println("Detecting faces in a remote image ...")
    if len(*imageAnalysis.Faces) == 0 {
        fmt.Println("No faces detected.")
    } else {
        // Print the bounding box locations of the found faces.
        for _, face := range *imageAnalysis.Faces {
            fmt.Printf("'%v' of age %v at location (%v, %v), (%v, %v)\n",
                face.Gender, *face.Age,
                *face.FaceRectangle.Left, *face.FaceRectangle.Top,
                *face.FaceRectangle.Left + *face.FaceRectangle.Width,
                *face.FaceRectangle.Top + *face.FaceRectangle.Height)
        }
    }
    fmt.Println()
}

Detectar conteúdo para adulto, erótico ou violento

A função a seguir imprime a presença detectada de conteúdo para adulto na imagem. Para obter mais informações, confira Conteúdo para adulto, erótico e violento.

func DetectAdultOrRacyContentRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT ADULT OR RACY CONTENT - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the features you want returned from the API call.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesAdult}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "") // language, English is default
    if err != nil { log.Fatal(err) }

    // Print whether or not there is questionable content.
    // Confidence levels: low means content is OK, high means it's not.
    fmt.Println("Analyzing remote image for adult or racy content: ");
    fmt.Printf("Is adult content: %v with confidence %.2f%%\n", *imageAnalysis.Adult.IsAdultContent, *imageAnalysis.Adult.AdultScore * 100)
    fmt.Printf("Has racy content: %v with confidence %.2f%%\n", *imageAnalysis.Adult.IsRacyContent, *imageAnalysis.Adult.RacyScore * 100)
    fmt.Println()
}

Obter esquema de cores da imagem

A função a seguir imprime os atributos de cor detectados na imagem, como as cores dominantes e a cor de destaque. Para obter mais informações, consulte Esquemas de cores.

func DetectColorSchemeRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT COLOR SCHEME - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    // Define the features you'd like returned with the result.
    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesColor}
    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "") // language, English is default
    if err != nil { log.Fatal(err) }

    fmt.Println("Color scheme of the remote image: ");
    fmt.Printf("Is black and white: %v\n", *imageAnalysis.Color.IsBWImg)
    fmt.Printf("Accent color: 0x%v\n", *imageAnalysis.Color.AccentColor)
    fmt.Printf("Dominant background color: %v\n", *imageAnalysis.Color.DominantColorBackground)
    fmt.Printf("Dominant foreground color: %v\n", *imageAnalysis.Color.DominantColorForeground)
    fmt.Printf("Dominant colors: %v\n", strings.Join(*imageAnalysis.Color.DominantColors, ", "))
    fmt.Println()
}

Obter conteúdo específico do domínio

A Análise de Imagem pode usar modelos especializados para realizar análise adicional em imagens. Para obter mais informações, confira Conteúdo específico do domínio.

O código a seguir analisa dados sobre celebridades detectados na imagem.

func DetectDomainSpecificContentRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT DOMAIN-SPECIFIC CONTENT - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    fmt.Println("Detecting domain-specific content in the local image ...")

    // Check if there are any celebrities in the image.
    celebrities, err := client.AnalyzeImageByDomain(
            computerVisionContext,
            "celebrities",
            remoteImage,
            "") // language, English is default
    if err != nil { log.Fatal(err) }

    fmt.Println("\nCelebrities: ")

    // Marshal the output from AnalyzeImageByDomain into JSON.
    data, err := json.MarshalIndent(celebrities.Result, "", "\t")

    // Define structs for which to unmarshal the JSON.
    type Celebrities struct {
        Name string `json:"name"`
    }

    type CelebrityResult struct {
        Celebrities	[]Celebrities `json:"celebrities"`
    }

    var celebrityResult CelebrityResult

    // Unmarshal the data.
    err = json.Unmarshal(data, &celebrityResult)
    if err != nil { log.Fatal(err) }

    //	Check if any celebrities detected.
    if len(celebrityResult.Celebrities) == 0 {
        fmt.Println("No celebrities detected.")
    }	else {
        for _, celebrity := range celebrityResult.Celebrities {
            fmt.Printf("name: %v\n", celebrity.Name)
        }
    }

O código a seguir analisa dados sobre pontos de referência detectados na imagem.

    fmt.Println("\nLandmarks: ")

    // Check if there are any landmarks in the image.
    landmarks, err := client.AnalyzeImageByDomain(
            computerVisionContext,
            "landmarks",
            remoteImage,
            "")
    if err != nil { log.Fatal(err) }

    // Marshal the output from AnalyzeImageByDomain into JSON.
    data, err = json.MarshalIndent(landmarks.Result, "", "\t")

    // Define structs for which to unmarshal the JSON.
    type Landmarks struct {
        Name string `json:"name"`
    }

    type LandmarkResult struct {
        Landmarks	[]Landmarks `json:"landmarks"`
    }

    var landmarkResult LandmarkResult

    // Unmarshal the data.
    err = json.Unmarshal(data, &landmarkResult)
    if err != nil { log.Fatal(err) }

    // Check if any celebrities detected.
    if len(landmarkResult.Landmarks) == 0 {
        fmt.Println("No landmarks detected.")
    }	else {
        for _, landmark := range landmarkResult.Landmarks {
            fmt.Printf("name: %v\n", landmark.Name)
        }
    }
    fmt.Println()
}

Obter o tipo de imagem

A função a seguir imprime informações sobre o tipo de imagem —, seja clip-art ou desenho de uma linha.

func DetectImageTypesRemoteImage(client computervision.BaseClient, remoteImageURL string) {
    fmt.Println("-----------------------------------------")
    fmt.Println("DETECT IMAGE TYPES - remote")
    fmt.Println()
    var remoteImage computervision.ImageURL
    remoteImage.URL = &remoteImageURL

    features := []computervision.VisualFeatureTypes{computervision.VisualFeatureTypesImageType}

    imageAnalysis, err := client.AnalyzeImage(
            computerVisionContext,
            remoteImage,
            features,
            []computervision.Details{},
            "")
    if err != nil { log.Fatal(err) }

    fmt.Println("Image type of remote image:")

    fmt.Println("\nClip art type: ")
    switch *imageAnalysis.ImageType.ClipArtType {
    case 0:
        fmt.Println("Image is not clip art.")
    case 1:
        fmt.Println("Image is ambiguously clip art.")
    case 2:
        fmt.Println("Image is normal clip art.")
    case 3:
        fmt.Println("Image is good clip art.")
    }

    fmt.Println("\nLine drawing type: ")
    if *imageAnalysis.ImageType.LineDrawingType == 1 {
        fmt.Println("Image is a line drawing.")
    }	else {
        fmt.Println("Image is not a line drawing.")
    }
    fmt.Println()
}

Executar o aplicativo

Execute o aplicativo do seu diretório de aplicativo com o comando go run.

go run sample-app.go

Limpar os recursos

Se quiser limpar e remover uma assinatura dos Serviços Cognitivos, você poderá excluir o recurso ou grupo de recursos. Excluir o grupo de recursos também exclui todos os recursos associados a ele.

Próximas etapas

Neste guia de início rápido, você aprendeu a instalar a biblioteca de clientes da Análise de Imagem e a fazer chamadas básicas de análise de imagem. A seguir, saiba mais sobre os recursos da API de Análise.

Use a API REST de Análise de Imagem para:

  • Analisar uma imagem quanto a marcas, descrição de texto, rostos, conteúdo para adulto e muito mais.
  • Gerar uma miniatura com corte inteligente

Observação

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. Confira as amostras do GitHub para obter exemplos em C#, Python, Java, JavaScript e Go.

Pré-requisitos

  • Uma assinatura do Azure – crie uma gratuitamente
  • Depois de obter sua assinatura do Azure, crie um recurso da Pesquisa Visual Computacional no portal do Azure para obter a chave e o ponto de extremidade. Após a implantação, clique em Ir para o recurso.
    • Você precisará da chave e do ponto de extremidade do recurso criado para conectar seu aplicativo ao serviço de Pesquisa Visual Computacional. Cole a chave e o ponto de extremidade no código abaixo mais adiante no guia de início rápido.
    • Use o tipo de preço gratuito (F0) para experimentar o serviço e atualizar mais tarde para um nível pago para produção.
  • cURL instalado

Analisar uma imagem

Para analisar uma imagem a fim de obter uma variedade de recursos visuais, execute as seguintes etapas:

  1. Copie o seguinte comando em um editor de texto.
  2. Faça as alterações a seguir no comando quando necessário:
    1. Substitua o valor de <subscriptionKey> pela sua chave de assinatura.
    2. Substitua a primeira parte da URL de solicitação (westcentralus) pelo texto em sua URL de ponto de extremidade.

      Observação

      Os novos recursos criados após 1º de julho de 2019 usarão nomes de subdomínio personalizados. Para saber mais e para obter uma lista completa de pontos de extremidade regionais, confira Nomes de subdomínio personalizados para Serviços Cognitivos.

    3. Outra opção é alterar a URL da imagem no corpo da solicitação (http://upload.wikimedia.org/wikipedia/commons/3/3c/Shaki_waterfall.jpg\) para uma URL de uma imagem diferente a ser analisada.
  3. Abra una janela de prompt de comando.
  4. Cole o comando do editor de texto na janela do prompt de comando e, em seguida, execute-o.
curl -H "Ocp-Apim-Subscription-Key: <subscriptionKey>" -H "Content-Type: application/json" "https://westcentralus.api.cognitive.microsoft.com/vision/v3.2/analyze?visualFeatures=Categories,Description&details=Landmarks" -d "{\"url\":\"http://upload.wikimedia.org/wikipedia/commons/3/3c/Shaki_waterfall.jpg\"}"

Examinar a resposta

Uma resposta com êxito é retornada em JSON. O aplicativo de exemplo analisa e exibe uma resposta bem-sucedida na janela do prompt de comando, semelhante ao exemplo a seguir:

{
  "categories": [
    {
      "name": "outdoor_water",
      "score": 0.9921875,
      "detail": {
        "landmarks": []
      }
    }
  ],
  "description": {
    "tags": [
      "nature",
      "water",
      "waterfall",
      "outdoor",
      "rock",
      "mountain",
      "rocky",
      "grass",
      "hill",
      "covered",
      "hillside",
      "standing",
      "side",
      "group",
      "walking",
      "white",
      "man",
      "large",
      "snow",
      "grazing",
      "forest",
      "slope",
      "herd",
      "river",
      "giraffe",
      "field"
    ],
    "captions": [
      {
        "text": "a large waterfall over a rocky cliff",
        "confidence": 0.916458423253597
      }
    ]
  },
  "requestId": "b6e33879-abb2-43a0-a96e-02cb5ae0b795",
  "metadata": {
    "height": 959,
    "width": 1280,
    "format": "Jpeg"
  }
}

Gerar uma miniatura

Você pode usar a Análise de Imagem para gerar uma miniatura com o corte inteligente. Você especifica a altura e a largura desejada, que podem diferir da imagem de entrada quanto à taxa de proporção. A Análise de Imagem usa o corte inteligente para identificar a área de interesse de modo inteligente e gerar as coordenadas de corte em torno dessa região.

Para criar e executar o exemplo, siga estas etapas:

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

  2. Faça as alterações a seguir no comando quando necessário:

    1. Substitua o valor de <subscriptionKey> pela sua chave de assinatura.
    2. Substitua o valor de <thumbnailFile> pelo caminho e o nome do arquivo no qual salvar a imagem de miniatura retornada.
    3. Substitua a primeira parte da URL de solicitação (westcentralus) pelo texto em sua URL de ponto de extremidade.

      Observação

      Os novos recursos criados após 1º de julho de 2019 usarão nomes de subdomínio personalizados. Para saber mais e para obter uma lista completa de pontos de extremidade regionais, confira Nomes de subdomínio personalizados para Serviços Cognitivos.

    4. Opcionalmente, altere a URL da imagem no corpo da solicitação (https://upload.wikimedia.org/wikipedia/commons/thumb/5/56/Shorkie_Poo_Puppy.jpg/1280px-Shorkie_Poo_Puppy.jpg\) para a URL de uma imagem diferente da qual você deseja gerar uma miniatura.
  3. Abra una janela de prompt de comando.

  4. Cole o comando do editor de texto na janela do prompt de comando.

  5. Pressione Enter para executar o programa.

    curl -H "Ocp-Apim-Subscription-Key: <subscriptionKey>" -o <thumbnailFile> -H "Content-Type: application/json" "https://westus.api.cognitive.microsoft.com/vision/v3.2/generateThumbnail?width=100&height=100&smartCropping=true" -d "{\"url\":\"https://upload.wikimedia.org/wikipedia/commons/thumb/5/56/Shorkie_Poo_Puppy.jpg/1280px-Shorkie_Poo_Puppy.jpg\"}"
    

Examinar a resposta

Uma resposta bem-sucedida grava a imagem em miniatura para o arquivo especificado em <thumbnailFile>. Se a solicitação falhar, a resposta conterá um código de erro e uma mensagem para ajudar a determinar o que deu errado. Se a solicitação parece ter êxito, mas a miniatura criada não for um arquivo de imagem válido, talvez sua chave de assinatura não seja válida.

Próximas etapas

Neste guia de início rápido, você aprendeu a instalar e fazer chamadas de análise de imagem básicas usando a API REST. A seguir, saiba mais sobre os recursos da API de Análise.