Detecta texto en archivos (PDF/TIFF)

La API de Vision puede detectar y transcribir texto de archivos PDF y TIFF almacenados en Cloud Storage.

La detección de texto en documentos PDF y TIFF se debe solicitar mediante la función files:asyncBatchAnnotate, que realiza una solicitud sin conexión (asíncrona) y proporciona su estado mediante los recursos operations.

El resultado de una solicitud de PDF o TIFF se escribe en un archivo JSON que se crea en el depósito de Cloud Storage especificado.

Limitaciones

La API de Vision acepta archivos PDF o TIFF de hasta 2,000 páginas. Los archivos más grandes generarán un error.

Autenticación

Las claves de API no son compatibles con las solicitudes files:asyncBatchAnnotate. Consulta Usa una cuenta de servicio si deseas obtener instrucciones para autenticar con una cuenta de servicio.

La cuenta que se use en la autenticación debe tener acceso al depósito de Cloud Storage que especifiques para el resultado (roles/editor o roles/storage.objectCreator o uno superior).

Puedes usar una clave de API a fin de consultar el estado de la operación. Consulta Usa una clave de API para obtener instrucciones.

Solicitudes de detección de texto en documentos

Por el momento, la detección en documentos PDF o TIFF solo está disponible para archivos almacenados en depósitos de Cloud Storage. Los archivos JSON de respuesta también se guardan en un depósito de Cloud Storage.

Página del PDF del censo estadounidense de 2010
gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf, Fuente: Oficina del Censo de los Estados Unidos.

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • cloud-storage-bucket: Un depósito o directorio de Cloud Storage para guardar los archivos de resultado, que se expresa con el siguiente formato:
    • gs://bucket/directory/
    El usuario que realice la solicitud debe tener permiso de escritura en el depósito.
  • cloud-storage-file-uri: La ruta a un archivo (PDF o TIFF) válido en un depósito de Cloud Storage. Como mínimo, debes tener privilegios de lectura en el archivo. Ejemplo:
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf

Consideraciones específicas del campo:

  • inputConfig: Reemplaza el campo image que se usa en otras solicitudes a la API de Vision. Contiene dos campos secundarios:
    • gcsSource.uri: El URI de Google Cloud Storage del archivo PDF o TIFF (al que puede acceder el usuario o la cuenta de servicio que realicen la solicitud)
    • mimeType: Uno de los tipos de archivo aceptados: application/pdf o image/tiff
  • outputConfig: Especifica los detalles del resultado. Contiene dos campos secundarios:
    • gcsDestination.uri: Un URI de Google Cloud Storage válido. El usuario o la cuenta de servicio que realicen la solicitud deben poder escribir en el depósito. El nombre del archivo será output-x-to-y, en el que x y y representan los números de página del PDF o TIFF incluidos en ese archivo de resultado. Si el archivo ya existe, se reemplazarán los contenidos.
    • batchSize: Especifica cuántas páginas de resultado se deben incluir en cada archivo JSON de resultado.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

    {
      "requests":[
        {
          "inputConfig": {
            "gcsSource": {
              "uri": "cloud-storage-file-uri"
            },
            "mimeType": "application/pdf"
          },
          "features": [
            {
              "type": "DOCUMENT_TEXT_DETECTION"
            }
          ],
          "outputConfig": {
            "gcsDestination": {
              "uri": "cloud-storage-bucket"
            },
            "batchSize": 1
          }
        }
      ]
    }
    

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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/files:asyncBatchAnnotate

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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/files:asyncBatchAnnotate" | Select-Object -Expand Content
Respuesta:

Una solicitud asyncBatchAnnotate correcta muestra una respuesta con un solo campo de nombre:

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

Este nombre representa una operación de larga duración con un ID asociado (por ejemplo, 1efec2285bd442df), que se puede consultar mediante la API de v1.operations.

Para recuperar tu respuesta de anotación de Vision, envía una solicitud GET al extremo v1.operations y pasa el ID de operación en la URL:

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

Por ejemplo:

    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 la operación están en curso, ejecuta el siguiente comando:

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

Una vez que la operación se completa, el state se muestra como DONE, y los resultados se escriben en el archivo de Google Cloud Storage que especificaste:

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

El JSON en el archivo de resultado es similar a la [solicitud de detección de texto del documento](/vision/docs/ocr) de una imagen y, además, tiene un campo context que muestra la ubicación del PDF o TIFF que se especificó y la cantidad de páginas en el archivo:

output-1-to-1.json

C#

Antes de probar esta muestra, sigue las instrucciones de configuración de C# que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para C#.

private static object DetectDocument(string gcsSourceUri,
        string gcsDestinationBucketName, string gcsDestinationPrefixName)
    {
        var client = ImageAnnotatorClient.Create();

        var asyncRequest = new AsyncAnnotateFileRequest
        {
            InputConfig = new InputConfig
            {
                GcsSource = new GcsSource
                {
                    Uri = gcsSourceUri
                },
                // Supported mime_types are: 'application/pdf' and 'image/tiff'
                MimeType = "application/pdf"
            },
            OutputConfig = new OutputConfig
            {
                // How many pages should be grouped into each json output file.
                BatchSize = 2,
                GcsDestination = new GcsDestination
                {
                    Uri = $"gs://{gcsDestinationBucketName}/{gcsDestinationPrefixName}"
                }
            }
        };

        asyncRequest.Features.Add(new Feature
        {
            Type = Feature.Types.Type.DocumentTextDetection
        });

        List<AsyncAnnotateFileRequest> requests =
            new List<AsyncAnnotateFileRequest>();
        requests.Add(asyncRequest);

        var operation = client.AsyncBatchAnnotateFiles(requests);

        Console.WriteLine("Waiting for the operation to finish");

        operation.PollUntilCompleted();

        // Once the rquest has completed and the output has been
        // written to GCS, we can list all the output files.
        var storageClient = StorageClient.Create();

        // List objects with the given prefix.
        var blobList = storageClient.ListObjects(gcsDestinationBucketName,
            gcsDestinationPrefixName);
        Console.WriteLine("Output files:");
        foreach (var blob in blobList)
        {
            Console.WriteLine(blob.Name);
        }

        // Process the first output file from GCS.
        // Select the first JSON file from the objects in the list.
        var output = blobList.Where(x => x.Name.Contains(".json")).First();

        var jsonString = "";
        using (var stream = new MemoryStream())
        {
            storageClient.DownloadObject(output, stream);
            jsonString = System.Text.Encoding.UTF8.GetString(stream.ToArray());
        }

        var response = JsonParser.Default
                    .Parse<AnnotateFileResponse>(jsonString);

        // The actual response for the first page of the input file.
        var firstPageResponses = response.Responses[0];
        var annotation = firstPageResponses.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
        Console.WriteLine($"Full text: \n {annotation.Text}");

        return 0;
    }

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de Go que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Go.


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

Antes de probar esta muestra, sigue las instrucciones de configuración de Java que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para 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 {
      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 output with the batch size.
        // The batch size sets how many pages should be grouped into each json 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 output has been
        // written to GCS, we can list all the 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 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

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Node.js.


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

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración de PHP que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para PHP.

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Storage\StorageClient;
    use Google\Cloud\Vision\V1\AnnotateFileResponse;
    use Google\Cloud\Vision\V1\AsyncAnnotateFileRequest;
    use Google\Cloud\Vision\V1\Feature;
    use Google\Cloud\Vision\V1\Feature\Type;
    use Google\Cloud\Vision\V1\GcsDestination;
    use Google\Cloud\Vision\V1\GcsSource;
    use Google\Cloud\Vision\V1\ImageAnnotatorClient;
    use Google\Cloud\Vision\V1\InputConfig;
    use Google\Cloud\Vision\V1\OutputConfig;

    // $path = 'gs://path/to/your/document.pdf'
    // $output = 'gs://path/to/store/results/'

    function detect_pdf_gcs($path, $output)
    {
        # select ocr feature
        $feature = (new Feature())
            ->setType(Type::DOCUMENT_TEXT_DETECTION);

        # set $path (file to OCR) as source
        $gcsSource = (new GcsSource())
            ->setUri($path);
        # supported mime_types are: 'application/pdf' and 'image/tiff'
        $mimeType = 'application/pdf';
        $inputConfig = (new InputConfig())
            ->setGcsSource($gcsSource)
            ->setMimeType($mimeType);

        # set $output as destination
        $gcsDestination = (new GcsDestination())
            ->setUri($output);
        # how many pages should be grouped into each json output file.
        $batchSize = 2;
        $outputConfig = (new OutputConfig())
            ->setGcsDestination($gcsDestination)
            ->setBatchSize($batchSize);

        # prepare request using configs set above
        $request = (new AsyncAnnotateFileRequest())
            ->setFeatures([$feature])
            ->setInputConfig($inputConfig)
            ->setOutputConfig($outputConfig);
        $requests = [$request];

        # make request
        $imageAnnotator = new ImageAnnotatorClient();
        $operation = $imageAnnotator->asyncBatchAnnotateFiles($requests);
        print('Waiting for operation to finish.' . PHP_EOL);
        $operation->pollUntilComplete();

        # once the request has completed and the output has been
        # written to GCS, we can list all the output files.
        preg_match('/^gs:\/\/([a-zA-Z0-9\._\-]+)\/?(\S+)?$/', $output, $match);
        $bucketName = $match[1];
        $prefix = isset($match[2]) ? $match[2] : '';

        $storage = new StorageClient();
        $bucket = $storage->bucket($bucketName);
        $options = ['prefix' => $prefix];
        $objects = $bucket->objects($options);

        # save first object for sample below
        $objects->next();
        $firstObject = $objects->current();

        # list objects with the given prefix.
        print('Output files:' . PHP_EOL);
        foreach ($objects as $object) {
            print($object->name() . PHP_EOL);
        }

        # 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.
        $jsonString = $firstObject->downloadAsString();
        $firstBatch = new AnnotateFileResponse();
        $firstBatch->mergeFromJsonString($jsonString);

        # get annotation and print text
        foreach ($firstBatch->getResponses() as $response) {
            $annotation = $response->getFullTextAnnotation();
            print($annotation->getText());
        }

        $imageAnnotator->close();
    }

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Python.

def async_detect_document(gcs_source_uri, gcs_destination_uri):
        """OCR with PDF/TIFF as source files on GCS"""
        import re
        from google.cloud import vision
        from google.cloud import storage
        from google.protobuf import json_format
        # 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.types.Feature(
            type=vision.enums.Feature.Type.DOCUMENT_TEXT_DETECTION)

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

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

        async_request = vision.types.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=180)

        # 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.
        blob_list = list(bucket.list_blobs(prefix=prefix))
        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_string()
        response = json_format.Parse(
            json_string, vision.types.AnnotateFileResponse())

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

        # 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(u'Full text:\n{}'.format(
            annotation.text))

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración de Ruby que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Ruby.

# gcs_source_uri = "Google Cloud Storage URI, eg. 'gs://my-bucket/example.pdf'"
    # gcs_destination_uri = "Google Cloud Storage URI, eg. 'gs://my-bucket/prefix_'"

    require "google/cloud/vision"
    require "google/cloud/storage"

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

    operation = image_annotator.document_text_detection(
      image:       gcs_source_uri,
      mime_type:   "application/pdf",
      batch_size:  2,
      destination: gcs_destination_uri,
      async:       true
    )

    puts "Waiting for the operation to finish."
    operation.wait_until_done!

    # Once the request has completed and the output has been
    # written to GCS, we can list all the output files.
    storage = Google::Cloud::Storage.new

    bucket_name, prefix = gcs_destination_uri.match("gs://([^/]+)/(.+)").captures
    bucket              = storage.bucket bucket_name

    # List objects with the given prefix.
    puts "Output files:"
    blob_list = bucket.files prefix: prefix
    blob_list.each do |file|
      puts file.name
    end

    # Process the first output file from GCS.
    # Since we specified a batch_size of 2, the first response contains
    # the first two pages of the input file.
    output      = blob_list[0]
    json_string = output.download
    response    = JSON.parse json_string.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
    puts "Full text:\n#{annotation['text']}"

Comando de gcloud

El comando de gcloud que uses dependerá del tipo de archivo.

  • Si quieres realizar la detección de texto PDF, usa el comando gcloud ml vision detect-text-pdf como se muestra en el siguiente ejemplo:

        gcloud ml vision detect-text-pdf gs://my_bucket/input_file  gs://my_bucket/out_put_prefix
        
  • Si quieres realizar la detección de texto TIFF, usa el comando gcloud ml vision detect-text-tiff como se muestra en el siguiente ejemplo:

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

Compatibilidad multirregional

Ahora puedes especificar el almacenamiento de datos a nivel de continente y el procesamiento de OCR. En este momento, se admiten las siguientes regiones:

  • us: Solo países de EE.UU.
  • eu: La Unión Europea

Ubicaciones

Cloud Vision te ofrece cierto control sobre dónde se almacenan y procesan los recursos de tu proyecto. En particular, puedes configurar Cloud Vision para almacenar y procesar tus datos solo en la Unión Europea.

De forma predeterminada, Cloud Vision almacena y procesa recursos en una ubicación global, lo que significa que Cloud Vision no garantiza que tus recursos permanezcan dentro de una región o ubicación en particular. Si eliges la ubicación de la Unión Europea, Google almacenará tus datos y solo se procesarán en esa ubicación. Tú y tus usuarios pueden acceder a los datos desde cualquier ubicación.

Configura la ubicación con la API

Cloud Vision es compatible con un extremo de la API global (vision.googleapis.com) y un extremo de la Unión Europea (eu-vision.googleapis.com). Para almacenar y procesar tus datos solo en la Unión Europea, usa el URI eu-vision.googleapis.com en lugar de vision.googleapis.com para las llamadas a la API de REST:

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

Configura la ubicación con las bibliotecas cliente

Las bibliotecas cliente de la API de Vision acceden al extremo global de la API (vision.googleapis.com) de forma predeterminada. Para almacenar y procesar tus datos solo en la Unión Europea, debes establecer el extremo (eu-vision.googleapis.com) de manera explícita. En las siguientes muestras de código se muestra cómo establecer esta configuración.

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los datos de solicitud que se muestran a continuación, realiza los siguientes reemplazos:

  • cloud-storage-image-uri: La ruta de acceso a un archivo de imagen válido en un depósito de Cloud Storage. Como mínimo, debes tener privilegios de lectura en el archivo. Ejemplo:
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • cloud-storage-bucket: Un depósito o directorio de Cloud Storage para guardar los archivos de resultado, que se expresa con el siguiente formato:
    • gs://bucket/directory/
    El usuario que realice la solicitud debe tener permiso de escritura en el depósito.

Consideraciones específicas del campo:

  • inputConfig: Reemplaza el campo image que se usa en otras solicitudes a la API de Vision. Contiene dos campos secundarios:
    • gcsSource.uri: El URI de Google Cloud Storage del archivo PDF o TIFF (al que puede acceder el usuario o la cuenta de servicio que realicen la solicitud)
    • mimeType: Uno de los tipos de archivo aceptados: application/pdf o image/tiff
  • outputConfig: Especifica los detalles del resultado. Contiene dos campos secundarios:
    • gcsDestination.uri: Un URI de Google Cloud Storage válido. El usuario o la cuenta de servicio que realicen la solicitud deben poder escribir en el depósito. El nombre del archivo será output-x-to-y, en el que x y y representan los números de página del PDF o TIFF incluidos en ese archivo de resultado. Si el archivo ya existe, se reemplazarán los contenidos.
    • batchSize: Especifica cuántas páginas de resultado se deben incluir en cada archivo JSON de resultado.

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

    {
      "requests":[
        {
          "inputConfig": {
            "gcsSource": {
              "uri": "cloud-storage-image-uri"
            },
            "mimeType": "application/pdf"
          },
          "features": [
            {
              "type": "DOCUMENT_TEXT_DETECTION"
            }
          ],
          "outputConfig": {
            "gcsDestination": {
              "uri": "cloud-storage-bucket"
            },
            "batchSize": 1
          }
        }
      ]
    }
    

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

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://eu-vision.googleapis.com/v1/files:asyncBatchAnnotate

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$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://eu-vision.googleapis.com/v1/files:asyncBatchAnnotate" | Select-Object -Expand Content
Respuesta:

Una solicitud asyncBatchAnnotate correcta muestra una respuesta con un solo campo de nombre:

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

Este nombre representa una operación de larga duración con un ID asociado (por ejemplo, 1efec2285bd442df), que se puede consultar mediante la API de v1.operations.

Para recuperar tu respuesta de anotación de Vision, envía una solicitud GET al extremo v1.operations y pasa el ID de operación en la URL:

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

Por ejemplo:

    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 la operación están en curso, ejecuta el siguiente comando:

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

Una vez que la operación se completa, el state se muestra como DONE, y los resultados se escriben en el archivo de Google Cloud Storage que especificaste:

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

El JSON en el archivo de resultado es similar a la [solicitud de detección de texto del documento](/vision/docs/ocr) de una imagen y, además, tiene un campo context que muestra la ubicación del PDF o TIFF que se especificó y la cantidad de páginas en el archivo:

output-1-to-1.json

C#

// Instantiate a client connected to the 'eu' location.
    var client = new ImageAnnotatorClientBuilder
    {
        Endpoint = new ServiceEndpoint("eu-vision.googleapis.com")
    }.Build();

Go

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: %v", err)
    	}
    	defer client.Close()

    	return nil
    }
    

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java que se encuentran en la Guía de inicio rápido de la API de Vision sobre cómo usar bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para 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

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

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

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

PHP

# set endpoint
    $options = ['api_endpoint' => $endpoint];

    $client = new ImageAnnotatorClient($options);

Python

from google.cloud import vision

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

    client = vision.ImageAnnotatorClient(client_options=client_options)

Ruby

require "google/cloud/vision"

    # Specifies the location of the api endpoint
    image_annotator = Google::Cloud::Vision::ImageAnnotator.new service_address: "eu-vision.googleapis.com"