Détecter le texte dans les fichiers (PDF/TIFF)

L'API Vision peut détecter et transcrire le texte des fichiers PDF et TIFF stockés dans Cloud Storage.

La détection du texte d'un document à partir de fichiers PDF et TIFF doit être initiée à l'aide de la fonction files:asyncBatchAnnotate qui effectue une requête hors ligne (asynchrone) et renvoie son état via les ressources operations.

Le résultat d'une requête PDF/TIFF est écrit dans un fichier JSON créé dans le bucket Cloud Storage spécifié.

Limites

L'API Vision accepte les fichiers PDF/TIFF jusqu'à 2 000 pages. Les fichiers plus volumineux renverront une erreur.

Authentification

Les clés API ne sont pas compatibles pour les requêtes files:asyncBatchAnnotate. Consultez la section Utiliser un compte de service pour des instructions sur l'authentification avec un compte de service.

Le compte utilisé pour l'authentification doit avoir accès au bucket Cloud Storage que vous spécifiez pour le résultat (roles/editor, roles/storage.objectCreator ou supérieur).

Cependant, vous pouvez utiliser une clé API pour suivre l'état de l'opération. Pour obtenir des instructions, consultez la section Utiliser une clé API.

Requêtes de détection de document texte

Pour le moment, la détection de texte dans des documents PDF et TIFF n'est disponible que si les fichiers sont stockés dans des buckets Cloud Storage. Les fichiers JSON résultats sont enregistrés de même dans un bucket Cloud Storage.

Page du PDF sur le recensement américain de 2010
gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf, Source : Bureau du recensement des États-Unis.

REST

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

  • CLOUD_STORAGE_BUCKET : répertoire/bucket Cloud Storage dans lequel enregistrer les fichiers de sortie, sous ce format :
    • gs://bucket/directory/
    L'utilisateur demandeur doit disposer d'autorisations en écriture sur le bucket.
  • CLOUD_STORAGE_FILE_URI : chemin d'accès à un fichier valide (PDF/TIFF) dans un bucket Cloud Storage. Il faut au minimum disposer des droits en lecture sur le fichier. Exemple :
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • FEATURE_TYPE : type de fonctionnalité valide. Pour les requêtes files:asyncBatchAnnotate, vous pouvez utiliser les types de fonctionnalités suivants :
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION
  • PROJECT_ID : ID de votre projet Google Cloud.

Remarque sur les champs :

  • inputConfig remplace le champ image utilisé dans d'autres requêtes de l'API Vision. Il contient deux sous-champs :
    • gcsSource.uri est l'URI Google Cloud Storage du fichier PDF ou TIFF (devant être accessible à l'utilisateur ou au compte de service à l'origine de la requête).
    • mimeType est l'un des types de fichiers acceptés : application/pdf ou image/tiff.
  • outputConfig sert à configurer le résultat. Il contient deux sous-champs :
    • gcsDestination.uri est un URI Google Cloud Storage qui doit être valide. Le bucket doit être accessible en écriture par l'utilisateur ou le compte de service à l’origine de la requête. Le nom du fichier sera output-x-to-y, où x et y représentent les numéros de page  PDF/TIFF inclus dans le fichier de sortie. Si un fichier portant le même nom existe déjà, son contenu sera écrasé.
    • batchSize est le nombre de pages à inclure dans chaque fichier JSON résultat.

Méthode HTTP et URL :

POST https://vision.googleapis.com/v1/files:asyncBatchAnnotate

Corps JSON de la requête : 

{
  "requests":[
    {
      "inputConfig": {
        "gcsSource": {
          "uri": "CLOUD_STORAGE_FILE_URI"
        },
        "mimeType": "application/pdf"
      },
      "features": [
        {
          "type": "FEATURE_TYPE"
        }
      ],
      "outputConfig": {
        "gcsDestination": {
          "uri": "CLOUD_STORAGE_BUCKET"
        },
        "batchSize": 1
      }
    }
  ]
}

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 print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://vision.googleapis.com/v1/files:asyncBatchAnnotate"

PowerShell

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

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

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

Une requête asyncBatchAnnotate réussie renvoie une réponse avec un champ de nom unique :

{
  "name": "projects/usable-auth-library/operations/1efec2285bd442df"
}

Sa valeur représente une opération de longue durée avec un identifiant associé (par exemple, 1efec2285bd442df), dont on peut vérifier l'état à l'aide de l'API v1.operations.

Pour récupérer le résultat de l'annotation par Vision, envoyez une requête GET au point de terminaison v1.operations en transmettant l'identifiant de l'opération dans l'URL.

GET https://vision.googleapis.com/v1/operations/operation-id

Exemple :

curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://vision.googleapis.com/v1/projects/project-id/locations/location-id/operations/1efec2285bd442df

Si l'opération est en cours :

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "RUNNING",
    "createTime": "2019-05-15T21:10:08.401917049Z",
    "updateTime": "2019-05-15T21:10:33.700763554Z"
  }
}

Une fois l'opération terminée, state prend la valeur DONE, et le résultat est enregistré dans le fichier Google Cloud Storage que vous avez spécifié :

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "DONE",
    "createTime": "2019-05-15T20:56:30.622473785Z",
    "updateTime": "2019-05-15T20:56:41.666379749Z"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.AsyncBatchAnnotateFilesResponse",
    "responses": [
      {
        "outputConfig": {
          "gcsDestination": {
            "uri": "gs://your-bucket-name/folder/"
          },
          "batchSize": 1
        }
      }
    ]
  }
}

Le fichier JSON résultat est semblable à celui produit par une [requête de détection du texte d'un document](/vision/docs/ocr) sur une image, avec simplement en plus le champ context qui indique l'emplacement du fichier PDF ou TIFF spécifié et le numéro des pages :

output-1-to-1.json

Go

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

Pour vous authentifier auprès de Vision, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


// detectAsyncDocumentURI performs Optical Character Recognition (OCR) on a
// PDF file stored in GCS.
func detectAsyncDocumentURI(w io.Writer, gcsSourceURI, gcsDestinationURI string) error {
	ctx := context.Background()

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

	request := &visionpb.AsyncBatchAnnotateFilesRequest{
		Requests: []*visionpb.AsyncAnnotateFileRequest{
			{
				Features: []*visionpb.Feature{
					{
						Type: visionpb.Feature_DOCUMENT_TEXT_DETECTION,
					},
				},
				InputConfig: &visionpb.InputConfig{
					GcsSource: &visionpb.GcsSource{Uri: gcsSourceURI},
					// Supported MimeTypes are: "application/pdf" and "image/tiff".
					MimeType: "application/pdf",
				},
				OutputConfig: &visionpb.OutputConfig{
					GcsDestination: &visionpb.GcsDestination{Uri: gcsDestinationURI},
					// How many pages should be grouped into each json output file.
					BatchSize: 2,
				},
			},
		},
	}

	operation, err := client.AsyncBatchAnnotateFiles(ctx, request)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Waiting for the operation to finish.")

	resp, err := operation.Wait(ctx)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "%v", resp)

	return nil
}

Java

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

/**
 * Performs document text OCR with PDF/TIFF as source files on Google Cloud Storage.
 *
 * @param gcsSourcePath The path to the remote file on Google Cloud Storage to detect document
 *     text on.
 * @param gcsDestinationPath The path to the remote file on Google Cloud Storage to store the
 *     results on.
 * @throws Exception on errors while closing the client.
 */
public static void detectDocumentsGcs(String gcsSourcePath, String gcsDestinationPath)
    throws Exception {

  // Initialize client that will be used to send requests. This client only needs to be created
  // once, and can be reused for multiple requests. After completing all of your requests, call
  // the "close" method on the client to safely clean up any remaining background resources.
  try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
    List<AsyncAnnotateFileRequest> requests = new ArrayList<>();

    // Set the GCS source path for the remote file.
    GcsSource gcsSource = GcsSource.newBuilder().setUri(gcsSourcePath).build();

    // Create the configuration with the specified MIME (Multipurpose Internet Mail Extensions)
    // types
    InputConfig inputConfig =
        InputConfig.newBuilder()
            .setMimeType(
                "application/pdf") // Supported MimeTypes: "application/pdf", "image/tiff"
            .setGcsSource(gcsSource)
            .build();

    // Set the GCS destination path for where to save the results.
    GcsDestination gcsDestination =
        GcsDestination.newBuilder().setUri(gcsDestinationPath).build();

    // Create the configuration for the System.output with the batch size.
    // The batch size sets how many pages should be grouped into each json System.output file.
    OutputConfig outputConfig =
        OutputConfig.newBuilder().setBatchSize(2).setGcsDestination(gcsDestination).build();

    // Select the Feature required by the vision API
    Feature feature = Feature.newBuilder().setType(Feature.Type.DOCUMENT_TEXT_DETECTION).build();

    // Build the OCR request
    AsyncAnnotateFileRequest request =
        AsyncAnnotateFileRequest.newBuilder()
            .addFeatures(feature)
            .setInputConfig(inputConfig)
            .setOutputConfig(outputConfig)
            .build();

    requests.add(request);

    // Perform the OCR request
    OperationFuture<AsyncBatchAnnotateFilesResponse, OperationMetadata> response =
        client.asyncBatchAnnotateFilesAsync(requests);

    System.out.println("Waiting for the operation to finish.");

    // Wait for the request to finish. (The result is not used, since the API saves the result to
    // the specified location on GCS.)
    List<AsyncAnnotateFileResponse> result =
        response.get(180, TimeUnit.SECONDS).getResponsesList();

    // Once the request has completed and the System.output has been
    // written to GCS, we can list all the System.output files.
    Storage storage = StorageOptions.getDefaultInstance().getService();

    // Get the destination location from the gcsDestinationPath
    Pattern pattern = Pattern.compile("gs://([^/]+)/(.+)");
    Matcher matcher = pattern.matcher(gcsDestinationPath);

    if (matcher.find()) {
      String bucketName = matcher.group(1);
      String prefix = matcher.group(2);

      // Get the list of objects with the given prefix from the GCS bucket
      Bucket bucket = storage.get(bucketName);
      com.google.api.gax.paging.Page<Blob> pageList = bucket.list(BlobListOption.prefix(prefix));

      Blob firstOutputFile = null;

      // List objects with the given prefix.
      System.out.println("Output files:");
      for (Blob blob : pageList.iterateAll()) {
        System.out.println(blob.getName());

        // Process the first System.output file from GCS.
        // Since we specified batch size = 2, the first response contains
        // the first two pages of the input file.
        if (firstOutputFile == null) {
          firstOutputFile = blob;
        }
      }

      // Get the contents of the file and convert the JSON contents to an AnnotateFileResponse
      // object. If the Blob is small read all its content in one request
      // (Note: the file is a .json file)
      // Storage guide: https://cloud.google.com/storage/docs/downloading-objects
      String jsonContents = new String(firstOutputFile.getContent());
      Builder builder = AnnotateFileResponse.newBuilder();
      JsonFormat.parser().merge(jsonContents, builder);

      // Build the AnnotateFileResponse object
      AnnotateFileResponse annotateFileResponse = builder.build();

      // Parse through the object to get the actual response for the first page of the input file.
      AnnotateImageResponse annotateImageResponse = annotateFileResponse.getResponses(0);

      // Here we print the full text from the first page.
      // The response contains more information:
      // annotation/pages/blocks/paragraphs/words/symbols
      // including confidence score and bounding boxes
      System.out.format("%nText: %s%n", annotateImageResponse.getFullTextAnnotation().getText());
    } else {
      System.out.println("No MATCH");
    }
  }
}

Node.js

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

Pour vous authentifier auprès de Vision, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


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

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// Bucket where the file resides
// const bucketName = 'my-bucket';
// Path to PDF file within bucket
// const fileName = 'path/to/document.pdf';
// The folder to store the results
// const outputPrefix = 'results'

const gcsSourceUri = `gs://${bucketName}/${fileName}`;
const gcsDestinationUri = `gs://${bucketName}/${outputPrefix}/`;

const inputConfig = {
  // Supported mime_types are: 'application/pdf' and 'image/tiff'
  mimeType: 'application/pdf',
  gcsSource: {
    uri: gcsSourceUri,
  },
};
const outputConfig = {
  gcsDestination: {
    uri: gcsDestinationUri,
  },
};
const features = [{type: 'DOCUMENT_TEXT_DETECTION'}];
const request = {
  requests: [
    {
      inputConfig: inputConfig,
      features: features,
      outputConfig: outputConfig,
    },
  ],
};

const [operation] = await client.asyncBatchAnnotateFiles(request);
const [filesResponse] = await operation.promise();
const destinationUri =
  filesResponse.responses[0].outputConfig.gcsDestination.uri;
console.log('Json saved to: ' + destinationUri);

Python

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

Pour vous authentifier auprès de Vision, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

def async_detect_document(gcs_source_uri, gcs_destination_uri):
    """OCR with PDF/TIFF as source files on GCS"""
    import json
    import re
    from google.cloud import vision
    from google.cloud import storage

    # Supported mime_types are: 'application/pdf' and 'image/tiff'
    mime_type = "application/pdf"

    # How many pages should be grouped into each json output file.
    batch_size = 2

    client = vision.ImageAnnotatorClient()

    feature = vision.Feature(type_=vision.Feature.Type.DOCUMENT_TEXT_DETECTION)

    gcs_source = vision.GcsSource(uri=gcs_source_uri)
    input_config = vision.InputConfig(gcs_source=gcs_source, mime_type=mime_type)

    gcs_destination = vision.GcsDestination(uri=gcs_destination_uri)
    output_config = vision.OutputConfig(
        gcs_destination=gcs_destination, batch_size=batch_size
    )

    async_request = vision.AsyncAnnotateFileRequest(
        features=[feature], input_config=input_config, output_config=output_config
    )

    operation = client.async_batch_annotate_files(requests=[async_request])

    print("Waiting for the operation to finish.")
    operation.result(timeout=420)

    # Once the request has completed and the output has been
    # written to GCS, we can list all the output files.
    storage_client = storage.Client()

    match = re.match(r"gs://([^/]+)/(.+)", gcs_destination_uri)
    bucket_name = match.group(1)
    prefix = match.group(2)

    bucket = storage_client.get_bucket(bucket_name)

    # List objects with the given prefix, filtering out folders.
    blob_list = [
        blob
        for blob in list(bucket.list_blobs(prefix=prefix))
        if not blob.name.endswith("/")
    ]
    print("Output files:")
    for blob in blob_list:
        print(blob.name)

    # Process the first output file from GCS.
    # Since we specified batch_size=2, the first response contains
    # the first two pages of the input file.
    output = blob_list[0]

    json_string = output.download_as_bytes().decode("utf-8")
    response = json.loads(json_string)

    # The actual response for the first page of the input file.
    first_page_response = response["responses"][0]
    annotation = first_page_response["fullTextAnnotation"]

    # Here we print the full text from the first page.
    # The response contains more information:
    # annotation/pages/blocks/paragraphs/words/symbols
    # including confidence scores and bounding boxes
    print("Full text:\n")
    print(annotation["text"])

gcloud

La commande gcloud à utiliser dépend du type de fichier à traiter.

  • Pour effectuer une détection de texte sur un PDF, utilisez la commande gcloud ml vision detect-text-pdf comme indiqué dans l'exemple suivant :

    gcloud ml vision detect-text-pdf gs://my_bucket/input_file  gs://my_bucket/out_put_prefix

  • Pour effectuer une détection de texte sur un fichier TIFF, utilisez la commande gcloud ml vision detect-text-tiff comme indiqué dans l'exemple suivant :

    gcloud ml vision detect-text-tiff gs://my_bucket/input_file  gs://my_bucket/out_put_prefix

Langages supplémentaires

C# : Veuillez suivre les Instructions de configuration de C# sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur Vision pour .NET.

PHP : Veuillez suivre les Instructions de configuration pour PHP sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur Vision pour PHP.

Ruby : Veuillez suivre les Instructions de configuration de Ruby sur la page des bibliothèques clientes, puis consultez la Documentation de référence sur Vision pour Ruby.

Stockage multirégional

Vous pouvez désormais spécifier le stockage de données et le traitement OCR au niveau du continent. Les régions actuellement compatibles sont les suivantes :

  • us : pays des États-Unis uniquement
  • eu : Union européenne

Emplacements

Cloud Vision vous permet de contrôler où les ressources de votre projet sont stockées et traitées. Vous pouvez notamment configurer Cloud Vision pour stocker vos données et ne procéder à leur traitement que dans l'Union européenne.

Dans Cloud Vision, les ressources sont stockées et traitées par défaut dans un emplacement global. Le maintien de vos ressources dans un emplacement ou une région spécifique n'est donc pas garanti. Pour que Google ne stocke et traite vos données que dans l'Union européenne, vous devez sélectionner la région Union européenne. Vous et vos utilisateurs pouvez accéder aux données depuis n'importe quel emplacement.

Définir l'emplacement à l'aide de l'API

L'API Vision accepte un point de terminaison global d'API (vision.googleapis.com), ainsi que deux points de terminaison régionaux : un point de terminaison en Union européenne (eu-vision.googleapis.com) et un point de terminaison aux États-Unis (us-vision.googleapis.com). Utilisez ces points de terminaison pour un traitement spécifique à la région. Par exemple, pour stocker et traiter vos données dans l'Union européenne uniquement, utilisez l'URI eu-vision.googleapis.com à la place de vision.googleapis.com pour vos appels d'API REST :

  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/images:annotate
  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/images:asyncBatchAnnotate
  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/files:annotate
  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/files:asyncBatchAnnotate

Pour stocker et traiter vos données aux États-Unis uniquement, utilisez le point de terminaison US (us-vision.googleapis.com) avec les méthodes précédentes.

Définir l'emplacement à l'aide des bibliothèques clientes

Par défaut, les bibliothèques clientes de l'API Vision accèdent au point de terminaison global de l'API (vision.googleapis.com). Pour ne stocker et traiter vos données qu'en Union européenne, vous devez définir explicitement le point de terminaison (eu-vision.googleapis.com). Les exemples de code ci-dessous indiquent comment configurer ce paramètre.

REST

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

  • REGION_ID : l'un des identifiants de zone géographique valides :
    • us : pays des États-Unis uniquement
    • eu : Union européenne
  • 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 : 
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • CLOUD_STORAGE_BUCKET : répertoire/bucket Cloud Storage dans lequel enregistrer les fichiers de sortie, sous ce format :
    • gs://bucket/directory/
    L'utilisateur demandeur doit disposer d'autorisations en écriture sur le bucket.
  • FEATURE_TYPE : type de fonctionnalité valide. Pour les requêtes files:asyncBatchAnnotate, vous pouvez utiliser les types de fonctionnalités suivants :
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION
  • PROJECT_ID : ID de votre projet Google Cloud.

Remarque sur les champs :

  • inputConfig remplace le champ image utilisé dans d'autres requêtes de l'API Vision. Il contient deux sous-champs :
    • gcsSource.uri est l'URI Google Cloud Storage du fichier PDF ou TIFF (devant être accessible à l'utilisateur ou au compte de service à l'origine de la requête).
    • mimeType est l'un des types de fichiers acceptés : application/pdf ou image/tiff.
  • outputConfig sert à configurer le résultat. Il contient deux sous-champs :
    • gcsDestination.uri est un URI Google Cloud Storage qui doit être valide. Le bucket doit être accessible en écriture par l'utilisateur ou le compte de service à l’origine de la requête. Le nom du fichier sera output-x-to-y, où x et y représentent les numéros de page  PDF/TIFF inclus dans le fichier de sortie. Si un fichier portant le même nom existe déjà, son contenu sera écrasé.
    • batchSize est le nombre de pages à inclure dans chaque fichier JSON résultat.

Méthode HTTP et URL :

POST https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/files:asyncBatchAnnotate

Corps JSON de la requête : 

{
  "requests":[
    {
      "inputConfig": {
        "gcsSource": {
          "uri": "CLOUD_STORAGE_IMAGE_URI"
        },
        "mimeType": "application/pdf"
      },
      "features": [
        {
          "type": "FEATURE_TYPE"
        }
      ],
      "outputConfig": {
        "gcsDestination": {
          "uri": "CLOUD_STORAGE_BUCKET"
        },
        "batchSize": 1
      }
    }
  ]
}

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 print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/files:asyncBatchAnnotate"

PowerShell

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

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/files:asyncBatchAnnotate" | Select-Object -Expand Content
Réponse :

Une requête asyncBatchAnnotate réussie renvoie une réponse avec un champ de nom unique :

{
  "name": "projects/usable-auth-library/operations/1efec2285bd442df"
}

Sa valeur représente une opération de longue durée avec un identifiant associé (par exemple, 1efec2285bd442df), dont on peut vérifier l'état à l'aide de l'API v1.operations.

Pour récupérer le résultat de l'annotation par Vision, envoyez une requête GET au point de terminaison v1.operations en transmettant l'identifiant de l'opération dans l'URL.

GET https://vision.googleapis.com/v1/operations/operation-id

Exemple :

curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://vision.googleapis.com/v1/projects/project-id/locations/location-id/operations/1efec2285bd442df

Si l'opération est en cours :

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "RUNNING",
    "createTime": "2019-05-15T21:10:08.401917049Z",
    "updateTime": "2019-05-15T21:10:33.700763554Z"
  }
}

Une fois l'opération terminée, state prend la valeur DONE, et le résultat est enregistré dans le fichier Google Cloud Storage que vous avez spécifié :

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "DONE",
    "createTime": "2019-05-15T20:56:30.622473785Z",
    "updateTime": "2019-05-15T20:56:41.666379749Z"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.AsyncBatchAnnotateFilesResponse",
    "responses": [
      {
        "outputConfig": {
          "gcsDestination": {
            "uri": "gs://your-bucket-name/folder/"
          },
          "batchSize": 1
        }
      }
    ]
  }
}

La réponse JSON dans votre fichier de sortie est semblable à celle produite par une réponse de détection d'un document texte sur une image si vous avez utilisé la fonctionnalité DOCUMENT_TEXT_DETECTION, ou par une requête de détection de texte si vous avez utilisé la fonctionnalité TEXT_DETECTION. Le résultat comporte un champ context supplémentaire indiquant l'emplacement du fichier PDF ou TIFF spécifié et son nombre de pages :

output-1-to-1.json

Go

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

Pour vous authentifier auprès de Vision, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import (
	"context"
	"fmt"

	vision "cloud.google.com/go/vision/apiv1"
	"google.golang.org/api/option"
)

// setEndpoint changes your endpoint.
func setEndpoint(endpoint string) error {
	// endpoint := "eu-vision.googleapis.com:443"

	ctx := context.Background()
	client, err := vision.NewImageAnnotatorClient(ctx, option.WithEndpoint(endpoint))
	if err != nil {
		return fmt.Errorf("NewImageAnnotatorClient: %w", err)
	}
	defer client.Close()

	return nil
}

Java

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

ImageAnnotatorSettings settings =
    ImageAnnotatorSettings.newBuilder().setEndpoint("eu-vision.googleapis.com:443").build();

// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
ImageAnnotatorClient client = ImageAnnotatorClient.create(settings);

Node.js

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

Pour vous authentifier auprès de Vision, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

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

async function setEndpoint() {
  // Specifies the location of the api endpoint
  const clientOptions = {apiEndpoint: 'eu-vision.googleapis.com'};

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

  // Performs text detection on the image file
  const [result] = await client.textDetection('./resources/wakeupcat.jpg');
  const labels = result.textAnnotations;
  console.log('Text:');
  labels.forEach(label => console.log(label.description));
}
setEndpoint();

Python

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

Pour vous authentifier auprès de Vision, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

from google.cloud import vision

client_options = {"api_endpoint": "eu-vision.googleapis.com"}

client = vision.ImageAnnotatorClient(client_options=client_options)

Faites l'essai

Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de l'API Cloud Vision en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Profiter d'un essai offert de l'API Cloud Vision