Détecter plusieurs objets

L'API Cloud Vision peut détecter et extraire plusieurs objets d'une image grâce à la localisation d'objets.

La localisation d'objets identifie plusieurs objets dans une image et fournit une annotation LocalizedObjectAnnotation pour chaque objet de l'image. Chaque valeur LocalizedObjectAnnotation identifie les informations sur l'objet, sa position et les limites rectangulaires de la région de l'image contenant l'objet.

Cela concerne à la fois les objets importants et ceux qui le sont moins.

Les informations sur les objets ne sont renvoyées qu'en anglais. Cloud Translation peut traduire les libellés en anglais dans plusieurs autres langues.

image avec cadres de délimitation
Crédit image : Bogdan Dada sur Unsplash (annotations ajoutées).

Par exemple, l'API pourrait renvoyer les informations et données de délimitation d'emplacement suivantes pour les objets de l'image ci-dessus :

Nom mid Score Limites
Bicycle wheel (roue de vélo) /m/01bqk0 0,89648587 (0,32076266, 0,78941387), (0,43812272, 0,78941387), (0,43812272, 0,97331065), (0,32076266, 0,97331065)
Bicycle (vélo) /m/0199g 0,886761 (0,312, 0,6616471), (0,638353, 0,6616471), (0,638353, 0,9705882), (0,312, 0,9705882)
Bicycle wheel (roue de vélo) /m/01bqk0 0,6345275 (0,5125398, 0,760708), (0,6256646, 0,760708), (0,6256646, 0,94601655), (0,5125398, 0,94601655)
Picture frame (cadre photo) /m/06z37_ 0,6207608 (0,79177403, 0,16160682), (0,97047985, 0,16160682), (0,97047985, 0,31348917), (0,79177403, 0,31348917)
Tire (pneu) /m/0h9mv 0,55886006 (0,32076266, 0,78941387), (0,43812272, 0,78941387), (0,43812272, 0,97331065), (0,32076266, 0,97331065)
Door (porte) /m/02dgv 0,5160098 (0,77569866, 0,37104446), (0,9412425, 0,37104446), (0,9412425, 0,81507325), (0,77569866, 0,81507325)

mid contient un identifiant généré automatiquement, correspondant à l'entrée d'un libellé sur Google Knowledge Graph. Pour plus d'informations sur l'inspection des valeurs mid, consultez la documentation de l'API Google Knowledge Graph Search.

Requêtes de localisation d'objets

Configurer votre authentification et votre projet GCP

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

Détecter des objets dans une image locale

L'API Vision peut détecter des fonctionnalités dans un fichier image local en envoyant le contenu du fichier image en tant que chaîne encodée en base64 dans le corps de votre requête.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • base64-encoded-image : représentation en base64 (chaîne ASCII) de vos données d'image binaire. Cette chaîne doit ressembler à la chaîne suivante :
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Consultez la rubrique encodage en base64 pour en savoir plus.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

Réponse :

C#

Avant d'essayer cet exemple, suivez les instructions de configuration de C# dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision C#.

            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

Avant d'essayer cet exemple, suivez les instructions de configuration de Go dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision Go.


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

Avant d'essayer cet exemple, suivez les instructions de configuration de Java dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Java.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Node.js dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Node.js.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de PHP dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision PHP.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Python dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Python.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Ruby dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Ruby.

# 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

Détecter des objets dans une image distante

Pour plus de facilité, l'API Vision peut directement détecter des fonctionnalités dans un fichier image de Google Cloud Storage ou sur le Web sans envoyer le contenu du fichier image dans le corps de votre requête.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • cloud-storage-image-uri : chemin d'accès à un fichier image valide dans un bucket Cloud Storage. Il faut au minimum disposer des droits en lecture sur le fichier. Exemple :
    • https://cloud.google.com/vision/docs/images/bicycle_example.png

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

Réponse :

C#

Avant d'essayer cet exemple, suivez les instructions de configuration de C# dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision C#.

            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

Avant d'essayer cet exemple, suivez les instructions de configuration de Go dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision Go.


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

Avant d'essayer cet exemple, suivez les instructions de configuration de Java dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Java.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Node.js dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Node.js.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de PHP dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision PHP.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Python dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Python.

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

Avant d'essayer cet exemple, suivez les instructions de configuration de Ruby dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Ruby.

# 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

Commande gcloud

Pour détecter les libellés dans une image, utilisez la commande gcloud ml vision detect-objects comme indiqué dans l'exemple suivant :

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

Essayer

Essayez la détection et la localisation des objets ci-dessous. Vous pouvez utiliser l'image déjà spécifiée https://cloud.google.com/vision/docs/images/bicycle_example.png ou spécifier votre propre image à la place. Envoyez la requête en sélectionnant Exécuter.

image sans cadres de délimitation
Crédit image : Bogdan Dada sur Unsplash.