Detectar vários objetos

A API do Cloud Vision consegue detectar e extrair vários objetos de uma imagem com a localização de objetos.

A localização de objetos identifica vários itens em uma imagem e fornece um LocalizedObjectAnnotation para cada um deles. Cada LocalizedObjectAnnotation identifica informações sobre o objeto, a posição dele e limites retangulares para a região da imagem que o contém.

A localização também identifica objetos significativos e menos proeminentes em uma imagem.

As informações do objeto são retornadas apenas em inglês. Esses rótulos podem ser traduzidos para vários idiomas com o Cloud Translation.

imagem com caixas delimitadoras
Crédito da imagem: Bogdan Dada em Unsplash (anotações adicionadas) [links em inglês].

Por exemplo, a API pode retornar as seguintes informações e dados de local delimitadores para os objetos na imagem acima:

Nome mid Pontuação Limites
Roda de bicicleta /m/01bqk0 0.89648587 (0.32076266, 0.78941387), (0.43812272, 0.78941387), (0.43812272, 0.97331065), (0.32076266, 0.97331065)
Bicicleta /m/0199g 0.886761 (0.312, 0.6616471), (0.638353, 0.6616471), (0.638353, 0.9705882), (0.312, 0.9705882)
Roda de bicicleta /m/01bqk0 0.6345275 (0.5125398, 0.760708), (0.6256646, 0.760708), (0.6256646, 0.94601655), (0.5125398, 0.94601655)
Moldura /m/06z37_ 0.6207608 (0.79177403, 0.16160682), (0.97047985, 0.16160682), (0.97047985, 0.31348917), (0.79177403, 0.31348917)
Pneu /m/0h9mv 0.55886006 (0.32076266, 0.78941387), (0.43812272, 0.78941387), (0.43812272, 0.97331065), (0.32076266, 0.97331065)
Porta /m/02dgv 0.5160098 (0.77569866, 0.37104446), (0.9412425, 0.37104446), (0.9412425, 0.81507325), (0.77569866, 0.81507325)

Em mid, há um identificador gerado por máquina (MID, na sigla em inglês) correspondente a uma entrada de rótulo do Mapa de informações do Google (em inglês). Para mais informações sobre como inspecionar valores mid, consulte a documentação da API de pesquisa do Mapa de informações do Google

Solicitações de localização de objetos

Configurar autenticação e projeto do GCP

quickstart,gcloud_init vision.googleapis.com Cloud Vision API SERVICE_ACCOUNT True env_var

Detectar objetos em uma imagem local

The Vision API can perform feature detection on a local image file by sending the contents of the image file as a base64 encoded string in the body of your request.

REST e LINHA DE CMD

Antes de usar os dados de solicitação abaixo, faça as substituições a seguir:

  • base64-encoded-image: a representação em base64 (string ASCII) dos dados da imagem binária. Essa string precisa ser semelhante à seguinte:
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Para mais informações, consulte o tópico Codificação Base64.

Método HTTP e URL:

POST https://vision.googleapis.com/v1/images:annotate

Corpo JSON da solicitação:

    {
      "requests": [
        {
          "image": {
            "content": "base64-encoded-image"
          },
          "features": [
            {
              "maxResults": 10,
              "type": "OBJECT_LOCALIZATION"
            },
          ]
        }
      ]
    }
    

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://vision.googleapis.com/v1/images:annotate" | Select-Object -Expand Content

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON.

Resposta:

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para C# (em inglês).

            var client = ImageAnnotatorClient.Create();
                var response = client.DetectLocalizedObjects(image);

                Console.WriteLine($"Number of objects found {response.Count}");
                foreach (var localizedObject in response)
                {
                    Console.Write($"\n{localizedObject.Name}");
                    Console.WriteLine($" (confidence: {localizedObject.Score})");
                    Console.WriteLine("Normalized bounding polygon vertices: ");

                    foreach (var vertex
                            in localizedObject.BoundingPoly.NormalizedVertices)
                    {
                        Console.WriteLine($" - ({vertex.X}, {vertex.Y})");
                    }
                }

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Go (em inglês).


    // localizeObjects gets objects and bounding boxes from the Vision API for an image at the given file path.
    func localizeObjects(w io.Writer, file string) error {
    	ctx := context.Background()

    	client, err := vision.NewImageAnnotatorClient(ctx)
    	if err != nil {
    		return err
    	}

    	f, err := os.Open(file)
    	if err != nil {
    		return err
    	}
    	defer f.Close()

    	image, err := vision.NewImageFromReader(f)
    	if err != nil {
    		return err
    	}
    	annotations, err := client.LocalizeObjects(ctx, image, nil)
    	if err != nil {
    		return err
    	}

    	if len(annotations) == 0 {
    		fmt.Fprintln(w, "No objects found.")
    		return nil
    	}

    	fmt.Fprintln(w, "Objects:")
    	for _, annotation := range annotations {
    		fmt.Fprintln(w, annotation.Name)
    		fmt.Fprintln(w, annotation.Score)

    		for _, v := range annotation.BoundingPoly.NormalizedVertices {
    			fmt.Fprintf(w, "(%f,%f)\n", v.X, v.Y)
    		}
    	}

    	return nil
    }
    

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Java (em inglês).

/**
     * Detects localized objects in the specified local image.
     *
     * @param filePath The path to the file to perform localized object detection on.
     * @param out A {@link PrintStream} to write detected objects to.
     * @throws Exception on errors while closing the client.
     * @throws IOException on Input/Output errors.
     */
    public static void detectLocalizedObjects(String filePath, PrintStream out)
        throws Exception, IOException {
      List<AnnotateImageRequest> requests = new ArrayList<>();

      ByteString imgBytes = ByteString.readFrom(new FileInputStream(filePath));

      Image img = Image.newBuilder().setContent(imgBytes).build();
      AnnotateImageRequest request =
          AnnotateImageRequest.newBuilder()
              .addFeatures(Feature.newBuilder().setType(Type.OBJECT_LOCALIZATION))
              .setImage(img)
              .build();
      requests.add(request);

      // Perform the request
      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();

        // Display the results
        for (AnnotateImageResponse res : responses) {
          for (LocalizedObjectAnnotation entity : res.getLocalizedObjectAnnotationsList()) {
            out.format("Object name: %s\n", entity.getName());
            out.format("Confidence: %s\n", entity.getScore());
            out.format("Normalized Vertices:\n");
            entity
                .getBoundingPoly()
                .getNormalizedVerticesList()
                .forEach(vertex -> out.format("- (%s, %s)\n", vertex.getX(), vertex.getY()));
          }
        }
      }
    }

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Node.js (em inglês).

// Imports the Google Cloud client libraries
    const vision = require('@google-cloud/vision');
    const fs = require('fs');

    // Creates a client
    const client = new vision.ImageAnnotatorClient();

    /**
     * TODO(developer): Uncomment the following line before running the sample.
     */
    // const fileName = `/path/to/localImage.png`;
    const request = {
      image: {content: fs.readFileSync(fileName)},
    };

    const [result] = await client.objectLocalization(request);
    const objects = result.localizedObjectAnnotations;
    objects.forEach(object => {
      console.log(`Name: ${object.name}`);
      console.log(`Confidence: ${object.score}`);
      const vertices = object.boundingPoly.normalizedVertices;
      vertices.forEach(v => console.log(`x: ${v.x}, y:${v.y}`));
    });

PHP

Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para PHP (em inglês).

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

    // $path = 'path/to/your/image.jpg'

    function detect_object($path)
    {
        $imageAnnotator = new ImageAnnotatorClient();

        # annotate the image
        $image = file_get_contents($path);
        $response = $imageAnnotator->objectLocalization($image);
        $objects = $response->getLocalizedObjectAnnotations();

        foreach ($objects as $object) {
            $name = $object->getName();
            $score = $object->getScore();
            $vertices = $object->getBoundingPoly()->getNormalizedVertices();

            printf('%s (confidence %d)):' . PHP_EOL, $name, $score);
            print('normalized bounding polygon vertices: ');
            foreach ($vertices as $vertex) {
                printf(' (%d, %d)', $vertex->getX(), $vertex->getY());
            }
            print(PHP_EOL);
        }

        $imageAnnotator->close();
    }

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Python (em inglês).

def localize_objects(path):
        """Localize objects in the local image.

        Args:
        path: The path to the local file.
        """
        from google.cloud import vision
        client = vision.ImageAnnotatorClient()

        with open(path, 'rb') as image_file:
            content = image_file.read()
        image = vision.types.Image(content=content)

        objects = client.object_localization(
            image=image).localized_object_annotations

        print('Number of objects found: {}'.format(len(objects)))
        for object_ in objects:
            print('\n{} (confidence: {})'.format(object_.name, object_.score))
            print('Normalized bounding polygon vertices: ')
            for vertex in object_.bounding_poly.normalized_vertices:
                print(' - ({}, {})'.format(vertex.x, vertex.y))

Ruby

Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Ruby (em inglês).

# image_path = "Path to local image file, eg. './image.png'"

    require "google/cloud/vision"

    image_annotator = Google::Cloud::Vision::ImageAnnotator.new

    response = image_annotator.object_localization_detection image: image_path

    response.responses.each do |res|
      res.localized_object_annotations.each do |object|
        puts "#{object.name} (confidence: #{object.score})"
        puts "Normalized bounding polygon vertices:"
        object.bounding_poly.normalized_vertices.each do |vertex|
          puts " - (#{vertex.x}, #{vertex.y})"
        end
      end
    end

Detectar objetos em uma imagem remota

Para sua conveniência, a API Vision pode realizar a detecção de recursos diretamente em um arquivo de imagem localizado no Google Cloud Storage ou na Web sem a necessidade de enviar o conteúdo do arquivo de imagem no corpo da solicitação.

REST e LINHA DE CMD

Antes de usar os dados de solicitação abaixo, faça as substituições a seguir:

  • cloud-storage-image-uri: o caminho para um arquivo de imagem válido em um intervalo do Cloud Storage. Você precisa ter, pelo menos, privilégios de leitura para o arquivo. Exemplo:
    • https://cloud.google.com/vision/docs/images/bicycle_example.png

Método HTTP e URL:

POST https://vision.googleapis.com/v1/images:annotate

Corpo JSON da solicitação:

    {
      "requests": [
        {
          "image": {
            "source": {
              "imageUri": "cloud-storage-image-uri"
            }
          },
          "features": [
            {
              "maxResults": 10,
              "type": "OBJECT_LOCALIZATION"
            },
          ]
        }
      ]
    }
    

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

Salve o corpo da solicitação em um arquivo chamado request.json e execute o comando a seguir:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://vision.googleapis.com/v1/images:annotate" | Select-Object -Expand Content

Quando a solicitação é bem-sucedida, o servidor retorna um código de status HTTP 200 OK e a resposta no formato JSON.

Resposta:

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para C# (em inglês).

            var client = ImageAnnotatorClient.Create();
                var response = client.DetectLocalizedObjects(image);

                Console.WriteLine($"Number of objects found {response.Count}");
                foreach (var localizedObject in response)
                {
                    Console.Write($"\n{localizedObject.Name}");
                    Console.WriteLine($" (confidence: {localizedObject.Score})");
                    Console.WriteLine("Normalized bounding polygon vertices: ");

                    foreach (var vertex
                            in localizedObject.BoundingPoly.NormalizedVertices)
                    {
                        Console.WriteLine($" - ({vertex.X}, {vertex.Y})");
                    }
                }

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Go (em inglês).


    // localizeObjects gets objects and bounding boxes from the Vision API for an image at the given file path.
    func localizeObjectsURI(w io.Writer, file string) error {
    	ctx := context.Background()

    	client, err := vision.NewImageAnnotatorClient(ctx)
    	if err != nil {
    		return err
    	}

    	image := vision.NewImageFromURI(file)
    	annotations, err := client.LocalizeObjects(ctx, image, nil)
    	if err != nil {
    		return err
    	}

    	if len(annotations) == 0 {
    		fmt.Fprintln(w, "No objects found.")
    		return nil
    	}

    	fmt.Fprintln(w, "Objects:")
    	for _, annotation := range annotations {
    		fmt.Fprintln(w, annotation.Name)
    		fmt.Fprintln(w, annotation.Score)

    		for _, v := range annotation.BoundingPoly.NormalizedVertices {
    			fmt.Fprintf(w, "(%f,%f)\n", v.X, v.Y)
    		}
    	}

    	return nil
    }
    

Java

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Java (em inglês).

/**
     * Detects localized objects in a remote image on Google Cloud Storage.
     *
     * @param gcsPath The path to the remote file on Google Cloud Storage to detect localized objects
     *     on.
     * @param out A {@link PrintStream} to write detected objects to.
     * @throws Exception on errors while closing the client.
     * @throws IOException on Input/Output errors.
     */
    public static void detectLocalizedObjectsGcs(String gcsPath, PrintStream out)
        throws Exception, IOException {
      List<AnnotateImageRequest> requests = new ArrayList<>();

      ImageSource imgSource = ImageSource.newBuilder().setGcsImageUri(gcsPath).build();
      Image img = Image.newBuilder().setSource(imgSource).build();

      AnnotateImageRequest request =
          AnnotateImageRequest.newBuilder()
              .addFeatures(Feature.newBuilder().setType(Type.OBJECT_LOCALIZATION))
              .setImage(img)
              .build();
      requests.add(request);

      // Perform the request
      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();
        client.close();
        // Display the results
        for (AnnotateImageResponse res : responses) {
          for (LocalizedObjectAnnotation entity : res.getLocalizedObjectAnnotationsList()) {
            out.format("Object name: %s\n", entity.getName());
            out.format("Confidence: %s\n", entity.getScore());
            out.format("Normalized Vertices:\n");
            entity
                .getBoundingPoly()
                .getNormalizedVerticesList()
                .forEach(vertex -> out.format("- (%s, %s)\n", vertex.getX(), vertex.getY()));
          }
        }
      }
    }

Node.js

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Node.js (em inglês).

// Imports the Google Cloud client libraries
    const vision = require('@google-cloud/vision');

    // Creates a client
    const client = new vision.ImageAnnotatorClient();

    /**
     * TODO(developer): Uncomment the following line before running the sample.
     */
    // const gcsUri = `gs://bucket/bucketImage.png`;

    const [result] = await client.objectLocalization(gcsUri);
    const objects = result.localizedObjectAnnotations;
    objects.forEach(object => {
      console.log(`Name: ${object.name}`);
      console.log(`Confidence: ${object.score}`);
      const veritices = object.boundingPoly.normalizedVertices;
      veritices.forEach(v => console.log(`x: ${v.x}, y:${v.y}`));
    });

PHP

Antes de testar esta amostra, siga as instruções de configuração do PHP no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para PHP (em inglês).

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

    // $path = 'gs://path/to/your/image.jpg'

    function detect_object_gcs($path)
    {
        $imageAnnotator = new ImageAnnotatorClient();

        # annotate the image
        $response = $imageAnnotator->objectLocalization($path);
        $objects = $response->getLocalizedObjectAnnotations();

        foreach ($objects as $object) {
            $name = $object->getName();
            $score = $object->getScore();
            $vertices = $object->getBoundingPoly()->getNormalizedVertices();

            printf('%s (confidence %d)):' . PHP_EOL, $name, $score);
            print('normalized bounding polygon vertices: ');
            foreach ($vertices as $vertex) {
                printf(' (%d, %d)', $vertex->getX(), $vertex->getY());
            }
            print(PHP_EOL);
        }

        $imageAnnotator->close();
    }

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Python (em inglês).

def localize_objects_uri(uri):
        """Localize objects in the image on Google Cloud Storage

        Args:
        uri: The path to the file in Google Cloud Storage (gs://...)
        """
        from google.cloud import vision
        client = vision.ImageAnnotatorClient()

        image = vision.types.Image()
        image.source.image_uri = uri

        objects = client.object_localization(
            image=image).localized_object_annotations

        print('Number of objects found: {}'.format(len(objects)))
        for object_ in objects:
            print('\n{} (confidence: {})'.format(object_.name, object_.score))
            print('Normalized bounding polygon vertices: ')
            for vertex in object_.bounding_poly.normalized_vertices:
                print(' - ({}, {})'.format(vertex.x, vertex.y))

Ruby

Antes de testar esta amostra, siga as instruções de configuração do Ruby no Guia de início rápido da API do Vision: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API do Vision para Ruby (em inglês).

# image_path = "Google Cloud Storage URI, eg. 'gs://my-bucket/image.png'"

    require "google/cloud/vision"

    image_annotator = Google::Cloud::Vision::ImageAnnotator.new

    response = image_annotator.object_localization_detection image: image_path

    response.responses.each do |res|
      res.localized_object_annotations.each do |object|
        puts "#{object.name} (confidence: #{object.score})"
        puts "Normalized bounding polygon vertices:"
        object.bounding_poly.normalized_vertices.each do |vertex|
          puts " - (#{vertex.x}, #{vertex.y})"
        end
      end
    end
    # image_path = "URI, eg. 'https://site.tld/image.png'"

    require "google/cloud/vision"

    image_annotator = Google::Cloud::Vision::ImageAnnotator.new

    response = image_annotator.object_localization_detection image: image_path

    response.responses.each do |res|
      res.localized_object_annotations.each do |object|
        puts "#{object.name} (confidence: #{object.score})"
        puts "Normalized bounding polygon vertices:"
        object.bounding_poly.normalized_vertices.each do |vertex|
          puts " - (#{vertex.x}, #{vertex.y})"
        end
      end
    end

Comando gcloud

Para detectar rótulos em uma imagem, use o comando gcloud ml vision detect-objects, como mostrado no exemplo a seguir:

    gcloud ml vision detect-objects https://cloud.google.com/vision/docs/images/bicycle_example.png
    

Testar

Tente detectar e localizar os objetos abaixo. É possível usar a imagem já especificada (https://cloud.google.com/vision/docs/images/bicycle_example.png) ou determinar sua própria imagem. Selecione Executar para enviar a solicitação.

imagem sem caixas delimitadoras
Crédito da imagem: Bogdan Dadá em Unsplash (links em inglês).