Rilevamento del testo nei file (PDF/TIFF)

L'API Vision può rilevare e trascrivere il testo dai file PDF e TIFF archiviati in Cloud Storage.

Il rilevamento del testo dei documenti da PDF e TIFF deve essere richiesto utilizzando la funzione files:asyncBatchAnnotate, che esegue una richiesta offline (asincrona) e fornisce il relativo stato utilizzando le risorse operations.

L'output di una richiesta PDF/TIFF viene scritto in un file JSON creato nel bucket Cloud Storage specificato.

Limitazioni

L'API Vision accetta file PDF/TIFF con un massimo di 2000 pagine. I file di dimensioni maggiori restituiranno un errore.

Autenticazione

Le chiavi API non sono supportate per le richieste files:asyncBatchAnnotate. Consulta Utilizzare un account di servizio per istruzioni sull'autenticazione con un account di servizio.

L'account utilizzato per l'autenticazione deve avere accesso al bucket Cloud Storage specificato per l'output (roles/editor o roles/storage.objectCreator o versioni successive).

Puoi utilizzare una chiave API per eseguire query sullo stato dell'operazione. Per istruzioni, consulta Utilizzare una chiave API.

Richieste di rilevamento del testo in documenti

Al momento, il rilevamento dei documenti PDF/TIFF è disponibile solo per i file archiviati nei bucket Cloud Storage. I file JSON di risposta vengono salvati in modo simile in un bucket Cloud Storage.

Pagina PDF del censimento degli Stati Uniti del 2010
gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf, Fonte: United States Census Bureau.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • CLOUD_STORAGE_BUCKET: un bucket/una directory Cloud Storage in cui salvare i file di output, espresso nel seguente formato:
    • gs://bucket/directory/
    L'utente che effettua la richiesta deve disporre dell'autorizzazione di scrittura per il bucket.
  • CLOUD_STORAGE_FILE_URI: il percorso di un file valido (PDF/TIFF) in un bucket Cloud Storage. Devi disporre almeno dei privilegi di lettura per il file. Esempio: 
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • FEATURE_TYPE: un tipo di elemento valido. Per le richieste files:asyncBatchAnnotate puoi utilizzare i seguenti tipi di funzionalità:
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION
  • PROJECT_ID: l'ID del tuo progetto Google Cloud.

Considerazioni specifiche per i campi:

  • inputConfig: sostituisce il campo image utilizzato in altre richieste dell'API Vision. Contiene due campi secondari:
    • gcsSource.uri: l'URI di Google Cloud Storage del file PDF o TIFF (accessibile all'utente o all'account di servizio che effettua la richiesta).
    • mimeType: uno dei tipi di file accettati: application/pdf o image/tiff.
  • outputConfig: specifica i dettagli dell'output. Contiene due campi secondari:
    • gcsDestination.uri: un URI Google Cloud Storage valido. Il bucket deve essere scritto dall'account utente o di servizio che effettua la richiesta. Il nome file sarà output-x-to-y, dove x e y rappresentano i numeri di pagina PDF/TIFF inclusi nel file di output. Se il file esiste, i suoi contenuti verranno sovrascritti.
    • batchSize: specifica quante pagine di output devono essere incluse in ogni file JSON di output.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

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

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

$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
Risposta:

Una richiesta asyncBatchAnnotate andata a buon fine restituisce una risposta con un singolo campo name:

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

Questo nome rappresenta un'operazione a lunga esecuzione con un ID associato (ad es. 1efec2285bd442df), su cui è possibile eseguire query utilizzando l'API v1.operations.

Per recuperare la risposta dell'annotazione di Vision, invia una richiesta GET all'endpoint v1.operations, passando l'ID operazione nell'URL:

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

Ad esempio:

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

Se l'operazione è in corso:

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

Al termine dell'operazione, state viene visualizzato come DONE e i risultati vengono scritti nel file Google Cloud Storage specificato:

{
  "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
        }
      }
    ]
  }
}

Il JSON nel file di output è simile a quello di una [richiesta di rilevamento del testo del documento](/vision/docs/ocr) di un'immagine, con l'aggiunta di un campo context che mostra la posizione del PDF o del TIFF specificato e il numero di pagine del file:

output-1-to-1.json

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Go.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida dell'API Vision sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento Java dell'API Vision.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Node.js.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Python.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Il comando gcloud che utilizzi dipende dal tipo di file.

  • Per eseguire il rilevamento del testo PDF, utilizza il comando gcloud ml vision detect-text-pdf come mostrato nell'esempio seguente:

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

  • Per eseguire il rilevamento del testo TIFF, utilizza il comando gcloud ml vision detect-text-tiff come mostrato nell'esempio seguente:

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

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di Vision per .NET.

PHP: segui le istruzioni di configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento di Vision per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi consulta la documentazione di riferimento di Vision per Ruby.

Supporto di più aree geografiche

Ora puoi specificare l'archiviazione dei dati e l'elaborazione OCR a livello di continente. Al momento sono supportate le seguenti regioni:

  • us: solo paese Stati Uniti
  • eu: l'Unione Europea

Località

Cloud Vision ti offre un certo controllo sulla posizione in cui vengono archiviate ed elaborate le risorse per il tuo progetto. In particolare, puoi configurare Cloud Vision per archiviare ed elaborare i tuoi dati solo nell'Unione Europea.

Per impostazione predefinita, Cloud Vision archivia ed elabora le risorse in una posizione globale, il che significa che Cloud Vision non garantisce che le risorse rimarranno all'interno di una determinata località o regione. Se scegli la località Unione Europea, Google archivia e tratta i tuoi dati solo nell'Unione Europea. Tu e i tuoi utenti potete accedere ai dati da qualsiasi posizione.

Impostazione della località tramite l'API

L'API Vision supporta un endpoint API globale (vision.googleapis.com) e anche due endpoint basati sulla regione: un endpoint per l'Unione Europea (eu-vision.googleapis.com) e un endpoint per gli Stati Uniti (us-vision.googleapis.com). Utilizza questi endpoint per l'elaborazione specifica per regione. Ad esempio, per archiviare ed elaborare i dati solo nell'Unione Europea, utilizza l'URI eu-vision.googleapis.com anziché vision.googleapis.com per le chiamate all'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

Per archiviare ed elaborare i dati solo negli Stati Uniti, utilizza l'endpoint statunitense (us-vision.googleapis.com) con i metodi precedenti.

Impostazione della località utilizzando le librerie client

Per impostazione predefinita, le librerie client dell'API Vision accedono all'endpoint API globale (vision.googleapis.com). Per archiviare ed elaborare i dati solo nell'Unione europea, devi impostare esplicitamente l'endpoint (eu-vision.googleapis.com). I seguenti esempi di codice mostrano come configurare questa impostazione.

REST

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • REGION_ID: uno degli identificatori di località regionali validi:
    • us: solo paese Stati Uniti
    • eu: l'Unione Europea
  • CLOUD_STORAGE_IMAGE_URI: il percorso di un file immagine valido in un bucket Cloud Storage. Devi disporre almeno dei privilegi di lettura per il file. Esempio: 
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • CLOUD_STORAGE_BUCKET: un bucket/una directory Cloud Storage in cui salvare i file di output, espresso nel seguente formato:
    • gs://bucket/directory/
    L'utente che effettua la richiesta deve disporre dell'autorizzazione di scrittura per il bucket.
  • FEATURE_TYPE: un tipo di elemento valido. Per le richieste files:asyncBatchAnnotate puoi utilizzare i seguenti tipi di funzionalità:
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION
  • PROJECT_ID: l'ID del tuo progetto Google Cloud.

Considerazioni specifiche per i campi:

  • inputConfig: sostituisce il campo image utilizzato in altre richieste dell'API Vision. Contiene due campi secondari:
    • gcsSource.uri: l'URI di Google Cloud Storage del file PDF o TIFF (accessibile all'utente o all'account di servizio che effettua la richiesta).
    • mimeType: uno dei tipi di file accettati: application/pdf o image/tiff.
  • outputConfig: specifica i dettagli dell'output. Contiene due campi secondari:
    • gcsDestination.uri: un URI Google Cloud Storage valido. Il bucket deve essere scritto dall'account utente o di servizio che effettua la richiesta. Il nome file sarà output-x-to-y, dove x e y rappresentano i numeri di pagina PDF/TIFF inclusi nel file di output. Se il file esiste, i suoi contenuti verranno sovrascritti.
    • batchSize: specifica quante pagine di output devono essere incluse in ogni file JSON di output.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

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

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

$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
Risposta:

Una richiesta asyncBatchAnnotate andata a buon fine restituisce una risposta con un singolo campo name:

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

Questo nome rappresenta un'operazione a lunga esecuzione con un ID associato (ad es. 1efec2285bd442df), su cui è possibile eseguire query utilizzando l'API v1.operations.

Per recuperare la risposta dell'annotazione di Vision, invia una richiesta GET all'endpoint v1.operations, passando l'ID operazione nell'URL:

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

Ad esempio:

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

Se l'operazione è in corso:

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

Al termine dell'operazione, state viene visualizzato come DONE e i risultati vengono scritti nel file Google Cloud Storage specificato:

{
  "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
        }
      }
    ]
  }
}

Il JSON nel file di output è simile a quello della risposta di rilevamento del testo del documento di un'immagine se hai utilizzato la funzionalità DOCUMENT_TEXT_DETECTION o della risposta di rilevamento del testo se hai utilizzato la funzionalità TEXT_DETECTION. L'output avrà un campo aggiuntivo context che mostra la posizione del file PDF o TIFF specificato e il numero di pagine del file:

output-1-to-1.json

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Go.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida dell'API Vision sull'utilizzo delle librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento Java dell'API Vision.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Node.js.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python riportate nella guida rapida di Vision con le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Vision Python.

Per autenticarti a Vision, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import vision

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

client = vision.ImageAnnotatorClient(client_options=client_options)

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni dell'API Cloud Vision in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova l'API Cloud Vision gratuitamente