Detectar escritura a mano en imágenes

Nota:

• ¿Usas esta API en una aplicación para dispositivos móviles? Prueba Firebase Machine Learning y ML Kit, que proporcionan SDKs de Android y iOS específicos de cada plataforma para usar los servicios de Cloud Vision, así como APIs de ML Vision en el dispositivo y la inferencia en el dispositivo mediante modelos de aprendizaje automático personalizados.
• La API Vision ahora admite la anotación de imágenes por lotes asíncrona sin conexión para todas las funciones. Esta solicitud asíncrona admite hasta 2000 archivos de imagen y devuelve archivos JSON de respuesta que se almacenan en tu segmento de Cloud Storage. Para obtener más información sobre esta función, consulta el artículo Anotación de imágenes por lotes sin conexión.

El precio de la detección de texto en documentos es el de la tarifa DOCUMENT_TEXT_DETECTION. Consulta la página de precios para obtener más información.

Detección de escritura a mano con reconocimiento óptico de caracteres (OCR)

La API Vision puede detectar y extraer texto de imágenes:

• DOCUMENT_TEXT_DETECTION extrae texto de una imagen (o de un archivo); la respuesta está optimizada para texto denso y documentos. El archivo JSON incluye información sobre páginas, bloques, párrafos, palabras y saltos de línea.

  

  Un uso específico de DOCUMENT_TEXT_DETECTION es detectar escritura a mano en una imagen.

  

Solicitudes de detección de texto en documentos

Configurar el Google Cloud proyecto y la autenticación

Si no has creado un Google Cloud proyecto, hazlo ahora. Despliega esta sección para ver las instrucciones.

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the Vision API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

4. Install the Google Cloud CLI.

5. Configura gcloud CLI para que use tu identidad federada.

   Para obtener más información, consulta el artículo Iniciar sesión en la CLI de gcloud con tu identidad federada.

6. Para inicializar gcloud CLI, ejecuta el siguiente comando:

   gcloud init

   Detectar texto de documentos en imágenes locales

   Puedes usar la API Vision para detectar rasgos en un archivo de imagen local.

   En el caso de las solicitudes REST, envíe el contenido del archivo de imagen como una cadena codificada en Base64 en el cuerpo de la solicitud.

   En el caso de las solicitudes de gcloud y de bibliotecas de cliente, especifica la ruta a una imagen local en tu solicitud.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • BASE64_ENCODED_IMAGE: representación en base64 (cadena ASCII) de los datos de imagen binarios. Esta cadena debe ser similar a la siguiente:
     • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
     Consulta el tema sobre la codificación en base64 para obtener más información.
   • PROJECT_ID: tu ID de proyecto Google Cloud .

   Método HTTP y URL:

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

   Cuerpo JSON de la solicitud:

   {
     "requests": [
       {
         "image": {
           "content": "BASE64_ENCODED_IMAGE"
         },
         "features": [
           {
             "type": "DOCUMENT_TEXT_DETECTION"
           }
         ]
       }
     ]
   }
   

   Para enviar tu solicitud, elige una de estas opciones:

   curl

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar la cuenta activa, ejecuta el comando gcloud auth list.

   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 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/images:annotate"

   PowerShell

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar la cuenta activa, ejecuta el comando gcloud auth list.

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

   $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/images:annotate" | Select-Object -Expand Content

   Si la solicitud se realiza de forma correcta, el servidor devuelve un código de estado HTTP 200 OK y la respuesta en formato JSON.

   Note: Zero coordinate values omitted. When the API detects a coordinate ("x" or "y") value of 0, that coordinate is omitted in the JSON response. Thus, a response with a bounding poly around the entire image would be
   [{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] for an image that is 100 pixels by 100 pixels. For more information, see the API Reference documentation.

   Respuesta

   {
     "responses": [
       {
         "textAnnotations": [
           {
             "locale": "en",
             "description": "O Google Cloud Platform\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 14,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 37
                 },
                 {
                   "x": 14,
                   "y": 37
                 }
               ]
             }
           },
         ],
         "fullTextAnnotation": {
           "pages": [
             {
               "property": {
                 "detectedLanguages": [
                   {
                     "languageCode": "en"
                   }
                 ]
               },
               "width": 281,
               "height": 44,
               "blocks": [
                 {
                   "property": {
                     "detectedLanguages": [
                       {
                         "languageCode": "en"
                       }
                     ]
                   },
                   "boundingBox": {
                     "vertices": [
                       {
                         "x": 14, "y": 11
                       },
                       {
                         "x": 279, "y": 11
                       },
                       {
                         "x": 279, "y": 37
                       },
                       {
                         "x": 14, "y": 37
                       }
                     ]
                   },
                   "paragraphs": [
                     {
                       "property": {
                         "detectedLanguages": [
                           {
                             "languageCode": "en"
                           }
                         ]
                       },
                       "boundingBox": {
                         "vertices": [
                           {
                             "x": 14, "y": 11
                           },
                           {
                             "x": 279, "y": 11
                           },
                           {
                             "x": 279, "y": 37
                           },
                           {
                             "x": 14, "y": 37
                           }
                         ]
                       },
                       "words": [
                         {
                           "property": {
                             "detectedLanguages": [
                               {
                                 "languageCode": "en"
                               }
                             ]
                           },
                           "boundingBox": {
                             "vertices": [
                               {
                                 "x": 14, "y": 11
                               },
                               {
                                 "x": 23, "y": 11
                               },
                               {
                                 "x": 23, "y": 37
                               },
                               {
                                 "x": 14, "y": 37
                               }
                             ]
                           },
                           "symbols": [
                             {
                               "property": {
                                 "detectedLanguages": [
                                   {
                                     "languageCode": "en"
                                   }
                                 ],
                                 "detectedBreak": {
                                   "type": "SPACE"
                                 }
                               },
                               "boundingBox": {
                                 "vertices": [
                                   {
                                     "x": 14, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 37
                                   },
                                   {
                                     "x": 14, "y": 37
                                   }
                                 ]
                               },
                               "text": "O"
                             }
                           ]
                         },
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 }
               ]
             }
           ],
           "text": "Google Cloud Platform\n"
         }
       }
     ]
   }
   

   Go

   Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   // detectDocumentText gets the full document text from the Vision API for an image at the given file path.
   func detectDocumentText(w io.Writer, file string) error {
   	ctx := context.Background()
   
   	client, err := vision.NewImageAnnotatorClient(ctx)
   	if err != nil {
   		return err
   	}
   
   	f, err := os.Open(file)
   	if err != nil {
   		return err
   	}
   	defer f.Close()
   
   	image, err := vision.NewImageFromReader(f)
   	if err != nil {
   		return err
   	}
   	annotation, err := client.DetectDocumentText(ctx, image, nil)
   	if err != nil {
   		return err
   	}
   
   	if annotation == nil {
   		fmt.Fprintln(w, "No text found.")
   	} else {
   		fmt.Fprintln(w, "Document Text:")
   		fmt.Fprintf(w, "%q\n", annotation.Text)
   
   		fmt.Fprintln(w, "Pages:")
   		for _, page := range annotation.Pages {
   			fmt.Fprintf(w, "\tConfidence: %f, Width: %d, Height: %d\n", page.Confidence, page.Width, page.Height)
   			fmt.Fprintln(w, "\tBlocks:")
   			for _, block := range page.Blocks {
   				fmt.Fprintf(w, "\t\tConfidence: %f, Block type: %v\n", block.Confidence, block.BlockType)
   				fmt.Fprintln(w, "\t\tParagraphs:")
   				for _, paragraph := range block.Paragraphs {
   					fmt.Fprintf(w, "\t\t\tConfidence: %f", paragraph.Confidence)
   					fmt.Fprintln(w, "\t\t\tWords:")
   					for _, word := range paragraph.Words {
   						symbols := make([]string, len(word.Symbols))
   						for i, s := range word.Symbols {
   							symbols[i] = s.Text
   						}
   						wordText := strings.Join(symbols, "")
   						fmt.Fprintf(w, "\t\t\t\tConfidence: %f, Symbols: %s\n", word.Confidence, wordText)
   					}
   				}
   			}
   		}
   	}
   
   	return nil
   }
   

   Java

   Antes de probar este ejemplo, sigue las instrucciones de configuración de Java que se indican en la guía de inicio rápido de la API Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Vision en Java.

   Nota: Para los usuarios del framework Spring de Java, Spring Cloud Google Cloud ofrece una forma de configurar automáticamente los ajustes de autenticación y los objetos de cliente para usar la API Vision.

   public static void detectDocumentText(String filePath) throws IOException {
     List<AnnotateImageRequest> requests = new ArrayList<>();
   
     ByteString imgBytes = ByteString.readFrom(new FileInputStream(filePath));
   
     Image img = Image.newBuilder().setContent(imgBytes).build();
     Feature feat = Feature.newBuilder().setType(Type.DOCUMENT_TEXT_DETECTION).build();
     AnnotateImageRequest request =
         AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
     requests.add(request);
   
     // 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()) {
       BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
       List<AnnotateImageResponse> responses = response.getResponsesList();
       client.close();
   
       for (AnnotateImageResponse res : responses) {
         if (res.hasError()) {
           System.out.format("Error: %s%n", res.getError().getMessage());
           return;
         }
   
         // For full list of available annotations, see http://g.co/cloud/vision/docs
         TextAnnotation annotation = res.getFullTextAnnotation();
         for (Page page : annotation.getPagesList()) {
           String pageText = "";
           for (Block block : page.getBlocksList()) {
             String blockText = "";
             for (Paragraph para : block.getParagraphsList()) {
               String paraText = "";
               for (Word word : para.getWordsList()) {
                 String wordText = "";
                 for (Symbol symbol : word.getSymbolsList()) {
                   wordText = wordText + symbol.getText();
                   System.out.format(
                       "Symbol text: %s (confidence: %f)%n",
                       symbol.getText(), symbol.getConfidence());
                 }
                 System.out.format(
                     "Word text: %s (confidence: %f)%n%n", wordText, word.getConfidence());
                 paraText = String.format("%s %s", paraText, wordText);
               }
               // Output Example using Paragraph:
               System.out.println("%nParagraph: %n" + paraText);
               System.out.format("Paragraph Confidence: %f%n", para.getConfidence());
               blockText = blockText + paraText;
             }
             pageText = pageText + blockText;
           }
         }
         System.out.println("%nComplete annotation:");
         System.out.println(annotation.getText());
       }
     }
   }

   Node.js

   Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   // Imports the Google Cloud client library
   const vision = require('@google-cloud/vision');
   
   // Creates a client
   const client = new vision.ImageAnnotatorClient();
   
   /**
    * TODO(developer): Uncomment the following line before running the sample.
    */
   // const fileName = 'Local image file, e.g. /path/to/image.png';
   
   // Read a local image as a text document
   const [result] = await client.documentTextDetection(fileName);
   const fullTextAnnotation = result.fullTextAnnotation;
   console.log(`Full text: ${fullTextAnnotation.text}`);
   fullTextAnnotation.pages.forEach(page => {
     page.blocks.forEach(block => {
       console.log(`Block confidence: ${block.confidence}`);
       block.paragraphs.forEach(paragraph => {
         console.log(`Paragraph confidence: ${paragraph.confidence}`);
         paragraph.words.forEach(word => {
           const wordText = word.symbols.map(s => s.text).join('');
           console.log(`Word text: ${wordText}`);
           console.log(`Word confidence: ${word.confidence}`);
           word.symbols.forEach(symbol => {
             console.log(`Symbol text: ${symbol.text}`);
             console.log(`Symbol confidence: ${symbol.confidence}`);
           });
         });
       });
     });
   });

   Python

   Antes de probar este ejemplo, sigue las Python instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   def detect_document(path):
       """Detects document features in an image."""
       from google.cloud import vision
   
       client = vision.ImageAnnotatorClient()
   
       with open(path, "rb") as image_file:
           content = image_file.read()
   
       image = vision.Image(content=content)
   
       response = client.document_text_detection(image=image)
   
       for page in response.full_text_annotation.pages:
           for block in page.blocks:
               print(f"\nBlock confidence: {block.confidence}\n")
   
               for paragraph in block.paragraphs:
                   print("Paragraph confidence: {}".format(paragraph.confidence))
   
                   for word in paragraph.words:
                       word_text = "".join([symbol.text for symbol in word.symbols])
                       print(
                           "Word text: {} (confidence: {})".format(
                               word_text, word.confidence
                           )
                       )
   
                       for symbol in word.symbols:
                           print(
                               "\tSymbol: {} (confidence: {})".format(
                                   symbol.text, symbol.confidence
                               )
                           )
   
       if response.error.message:
           raise Exception(
               "{}\nFor more info on error messages, check: "
               "https://cloud.google.com/apis/design/errors".format(response.error.message)
           )
   
   

   Idiomas adicionales

   C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Vision para .NET.

   PHP Sigue las instrucciones de configuración de PHP en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Vision para PHP.

   Ruby: Sigue las instrucciones de configuración de Ruby en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Vision para Ruby.

   Detectar texto de un documento en una imagen remota

   Puede usar la API Vision para detectar características en un archivo de imagen remoto que se encuentre en Cloud Storage o en la Web. Para enviar una solicitud de archivo remoto, especifica la URL web o el URI de Cloud Storage del archivo en el cuerpo de la solicitud.

   Precaución: Cuando se obtienen imágenes de URLs HTTP o HTTPS, Google no puede garantizar que la solicitud se complete. Es posible que tu solicitud falle si el host especificado la deniega (por ejemplo, debido a la limitación de solicitudes o a la prevención de DoS) o si Google limita las solicitudes al sitio para evitar abusos. Como práctica recomendada, no dependas de imágenes alojadas externamente para las aplicaciones de producción.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • CLOUD_STORAGE_IMAGE_URI: la ruta a un archivo de imagen válido en un segmento de Cloud Storage. Debe tener al menos privilegios de lectura en el archivo. Ejemplo:
     • gs://cloud-samples-data/vision/handwriting_image.png

   • PROJECT_ID: tu ID de proyecto Google Cloud .

   Método HTTP y URL:

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

   Cuerpo JSON de la solicitud:

   {
     "requests": [
       {
         "image": {
           "source": {
             "imageUri": "CLOUD_STORAGE_IMAGE_URI"
           }
          },
          "features": [
            {
              "type": "DOCUMENT_TEXT_DETECTION"
            }
          ]
       }
     ]
   }
   

   Para enviar tu solicitud, elige una de estas opciones:

   curl

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar la cuenta activa, ejecuta el comando gcloud auth list.

   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 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/images:annotate"

   PowerShell

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar la cuenta activa, ejecuta el comando gcloud auth list.

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

   $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/images:annotate" | Select-Object -Expand Content

   Si la solicitud se realiza de forma correcta, el servidor devuelve un código de estado HTTP 200 OK y la respuesta en formato JSON.

   Note: Zero coordinate values omitted. When the API detects a coordinate ("x" or "y") value of 0, that coordinate is omitted in the JSON response. Thus, a response with a bounding poly around the entire image would be
   [{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] for an image that is 100 pixels by 100 pixels. For more information, see the API Reference documentation.

   Respuesta

   {
     "responses": [
       {
         "textAnnotations": [
           {
             "locale": "en",
             "description": "O Google Cloud Platform\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 14,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 37
                 },
                 {
                   "x": 14,
                   "y": 37
                 }
               ]
             }
           },
         ],
         "fullTextAnnotation": {
           "pages": [
             {
               "property": {
                 "detectedLanguages": [
                   {
                     "languageCode": "en"
                   }
                 ]
               },
               "width": 281,
               "height": 44,
               "blocks": [
                 {
                   "property": {
                     "detectedLanguages": [
                       {
                         "languageCode": "en"
                       }
                     ]
                   },
                   "boundingBox": {
                     "vertices": [
                       {
                         "x": 14, "y": 11
                       },
                       {
                         "x": 279, "y": 11
                       },
                       {
                         "x": 279, "y": 37
                       },
                       {
                         "x": 14, "y": 37
                       }
                     ]
                   },
                   "paragraphs": [
                     {
                       "property": {
                         "detectedLanguages": [
                           {
                             "languageCode": "en"
                           }
                         ]
                       },
                       "boundingBox": {
                         "vertices": [
                           {
                             "x": 14, "y": 11
                           },
                           {
                             "x": 279, "y": 11
                           },
                           {
                             "x": 279, "y": 37
                           },
                           {
                             "x": 14, "y": 37
                           }
                         ]
                       },
                       "words": [
                         {
                           "property": {
                             "detectedLanguages": [
                               {
                                 "languageCode": "en"
                               }
                             ]
                           },
                           "boundingBox": {
                             "vertices": [
                               {
                                 "x": 14, "y": 11
                               },
                               {
                                 "x": 23, "y": 11
                               },
                               {
                                 "x": 23, "y": 37
                               },
                               {
                                 "x": 14, "y": 37
                               }
                             ]
                           },
                           "symbols": [
                             {
                               "property": {
                                 "detectedLanguages": [
                                   {
                                     "languageCode": "en"
                                   }
                                 ],
                                 "detectedBreak": {
                                   "type": "SPACE"
                                 }
                               },
                               "boundingBox": {
                                 "vertices": [
                                   {
                                     "x": 14, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 37
                                   },
                                   {
                                     "x": 14, "y": 37
                                   }
                                 ]
                               },
                               "text": "O"
                             }
                           ]
                         },
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 }
               ]
             }
           ],
           "text": "Google Cloud Platform\n"
         }
       }
     ]
   }
   

   Go

   Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   // detectDocumentText gets the full document text from the Vision API for an image at the given file path.
   func detectDocumentTextURI(w io.Writer, file string) error {
   	ctx := context.Background()
   
   	client, err := vision.NewImageAnnotatorClient(ctx)
   	if err != nil {
   		return err
   	}
   
   	image := vision.NewImageFromURI(file)
   	annotation, err := client.DetectDocumentText(ctx, image, nil)
   	if err != nil {
   		return err
   	}
   
   	if annotation == nil {
   		fmt.Fprintln(w, "No text found.")
   	} else {
   		fmt.Fprintln(w, "Document Text:")
   		fmt.Fprintf(w, "%q\n", annotation.Text)
   
   		fmt.Fprintln(w, "Pages:")
   		for _, page := range annotation.Pages {
   			fmt.Fprintf(w, "\tConfidence: %f, Width: %d, Height: %d\n", page.Confidence, page.Width, page.Height)
   			fmt.Fprintln(w, "\tBlocks:")
   			for _, block := range page.Blocks {
   				fmt.Fprintf(w, "\t\tConfidence: %f, Block type: %v\n", block.Confidence, block.BlockType)
   				fmt.Fprintln(w, "\t\tParagraphs:")
   				for _, paragraph := range block.Paragraphs {
   					fmt.Fprintf(w, "\t\t\tConfidence: %f", paragraph.Confidence)
   					fmt.Fprintln(w, "\t\t\tWords:")
   					for _, word := range paragraph.Words {
   						symbols := make([]string, len(word.Symbols))
   						for i, s := range word.Symbols {
   							symbols[i] = s.Text
   						}
   						wordText := strings.Join(symbols, "")
   						fmt.Fprintf(w, "\t\t\t\tConfidence: %f, Symbols: %s\n", word.Confidence, wordText)
   					}
   				}
   			}
   		}
   	}
   
   	return nil
   }
   

   Java

   Antes de probar este ejemplo, sigue las instrucciones de configuración de Java que se indican en la guía de inicio rápido de la API Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Vision en Java.

   Nota: Para los usuarios del framework Spring de Java, Spring Cloud Google Cloud ofrece una forma de configurar automáticamente los ajustes de autenticación y los objetos de cliente para usar la API Vision.

   public static void detectDocumentTextGcs(String gcsPath) throws IOException {
     List<AnnotateImageRequest> requests = new ArrayList<>();
   
     ImageSource imgSource = ImageSource.newBuilder().setGcsImageUri(gcsPath).build();
     Image img = Image.newBuilder().setSource(imgSource).build();
     Feature feat = Feature.newBuilder().setType(Type.DOCUMENT_TEXT_DETECTION).build();
     AnnotateImageRequest request =
         AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
     requests.add(request);
   
     // 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()) {
       BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
       List<AnnotateImageResponse> responses = response.getResponsesList();
       client.close();
   
       for (AnnotateImageResponse res : responses) {
         if (res.hasError()) {
           System.out.format("Error: %s%n", res.getError().getMessage());
           return;
         }
         // For full list of available annotations, see http://g.co/cloud/vision/docs
         TextAnnotation annotation = res.getFullTextAnnotation();
         for (Page page : annotation.getPagesList()) {
           String pageText = "";
           for (Block block : page.getBlocksList()) {
             String blockText = "";
             for (Paragraph para : block.getParagraphsList()) {
               String paraText = "";
               for (Word word : para.getWordsList()) {
                 String wordText = "";
                 for (Symbol symbol : word.getSymbolsList()) {
                   wordText = wordText + symbol.getText();
                   System.out.format(
                       "Symbol text: %s (confidence: %f)%n",
                       symbol.getText(), symbol.getConfidence());
                 }
                 System.out.format(
                     "Word text: %s (confidence: %f)%n%n", wordText, word.getConfidence());
                 paraText = String.format("%s %s", paraText, wordText);
               }
               // Output Example using Paragraph:
               System.out.println("%nParagraph: %n" + paraText);
               System.out.format("Paragraph Confidence: %f%n", para.getConfidence());
               blockText = blockText + paraText;
             }
             pageText = pageText + blockText;
           }
         }
         System.out.println("%nComplete annotation:");
         System.out.println(annotation.getText());
       }
     }
   }

   Node.js

   Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   
   // Imports the Google Cloud client libraries
   const vision = require('@google-cloud/vision');
   
   // Creates a client
   const client = new vision.ImageAnnotatorClient();
   
   /**
    * TODO(developer): Uncomment the following lines before running the sample.
    */
   // const bucketName = 'Bucket where the file resides, e.g. my-bucket';
   // const fileName = 'Path to file within bucket, e.g. path/to/image.png';
   
   // Read a remote image as a text document
   const [result] = await client.documentTextDetection(
     `gs://${bucketName}/${fileName}`
   );
   const fullTextAnnotation = result.fullTextAnnotation;
   console.log(fullTextAnnotation.text);

   Python

   Antes de probar este ejemplo, sigue las Python instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   def detect_document_uri(uri):
       """Detects document features in the file located in Google Cloud
       Storage."""
       from google.cloud import vision
   
       client = vision.ImageAnnotatorClient()
       image = vision.Image()
       image.source.image_uri = uri
   
       response = client.document_text_detection(image=image)
   
       for page in response.full_text_annotation.pages:
           for block in page.blocks:
               print(f"\nBlock confidence: {block.confidence}\n")
   
               for paragraph in block.paragraphs:
                   print("Paragraph confidence: {}".format(paragraph.confidence))
   
                   for word in paragraph.words:
                       word_text = "".join([symbol.text for symbol in word.symbols])
                       print(
                           "Word text: {} (confidence: {})".format(
                               word_text, word.confidence
                           )
                       )
   
                       for symbol in word.symbols:
                           print(
                               "\tSymbol: {} (confidence: {})".format(
                                   symbol.text, symbol.confidence
                               )
                           )
   
       if response.error.message:
           raise Exception(
               "{}\nFor more info on error messages, check: "
               "https://cloud.google.com/apis/design/errors".format(response.error.message)
           )
   
   

   gcloud

   Para detectar la escritura a mano, usa el comando gcloud ml vision detect-document como se muestra en el siguiente ejemplo:

   gcloud ml vision detect-document gs://cloud-samples-data/vision/handwriting_image.png
   

   Idiomas adicionales

   C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Vision para .NET.

   PHP Sigue las instrucciones de configuración de PHP en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Vision para PHP.

   Ruby: Sigue las instrucciones de configuración de Ruby en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Vision para Ruby.

   Especificar el idioma (opcional)

   Ambos tipos de solicitudes de OCR admiten uno o varios languageHints que especifican el idioma de cualquier texto de la imagen. Sin embargo, un valor vacío suele dar los mejores resultados, ya que si se omite un valor, se activa la detección automática del idioma. En el caso de los idiomas basados en el alfabeto latino, no es necesario definir languageHints. En casos excepcionales, cuando se conoce el idioma del texto de la imagen, definir una sugerencia ayuda a obtener mejores resultados (aunque puede ser un obstáculo importante si la sugerencia es incorrecta). La detección de texto devuelve un error si uno o varios de los idiomas especificados no se encuentran entre los idiomas admitidos.

   Si decide proporcionar una sugerencia de idioma, modifique el cuerpo de su solicitud (archivo request.json) para proporcionar la cadena de uno de los idiomas admitidos en el campo imageContext.languageHints, como se muestra en el siguiente ejemplo:

   {
     "requests": [
       {
         "image": {
           "source": {
             "imageUri": "IMAGE_URL"
           }
         },
         "features": [
           {
             "type": "DOCUMENT_TEXT_DETECTION"
           }
         ],
         "imageContext": {
           "languageHints": ["en-t-i0-handwrit"]
         }
       }
     ]
   }

   ¿Cómo funcionan las sugerencias de idioma?

   El formato languageHint sigue las directrices de formato de código de idioma BCP47. El formato especificado por BCP47 es el siguiente:

   language ["-" script] ["-" region] *("-" variant) *("-" extension) ["-" privateuse].

   Por ejemplo, la sugerencia de idioma "en-t-i0-handwrit" especifica el idioma inglés (en), el singleton de la extensión transform (t), el código de la extensión transform del motor del método de entrada (i0) y el código de transformación de escritura a mano (handwrit). Este código indica que el idioma es "inglés transformado a partir de escritura a mano". No es necesario que especifiques un código de secuencia de comandos porque Latn está implícito en el idioma "en".

   Asistencia multirregional

   Actualmente, esta función solo se aplica a la función OCR (tipos TEXT_DETECTION o DOCUMENT_TEXT_DETECTION).

   Ahora puedes especificar el almacenamiento de datos y el procesamiento OCR a nivel continental. Actualmente, se admiten las siguientes regiones:

   • us: solo en 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 concreto, puede configurar Cloud Vision para que almacene y trate sus datos únicamente en la Unión Europea.

   De forma predeterminada, Cloud Vision almacena y trata los recursos en una ubicación global, lo que significa que Cloud Vision no garantiza que tus recursos permanezcan en una ubicación o región concretas. Si eliges la ubicación Unión Europea, Google almacenará tus datos y los tratará únicamente en la Unión Europea. Tanto tú como tus usuarios podéis acceder a los datos desde cualquier ubicación.

   Definir la ubicación mediante la API

   La API Vision admite un punto de conexión de API global (vision.googleapis.com) y dos puntos de conexión basados en regiones: uno para la Unión Europea (eu-vision.googleapis.com) y otro para Estados Unidos (us-vision.googleapis.com). Utiliza estos puntos de conexión para el procesamiento específico de cada región. Por ejemplo, para almacenar y tratar tus datos solo en la Unión Europea, usa el URI eu-vision.googleapis.com en lugar de vision.googleapis.com en tus llamadas a la 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

   Para almacenar y tratar tus datos solo en Estados Unidos, utiliza el endpoint de EE. UU. (us-vision.googleapis.com) con los métodos anteriores.

   Definir la ubicación mediante las bibliotecas de cliente

   Las bibliotecas de cliente de la API Vision acceden al endpoint de la API global (vision.googleapis.com) de forma predeterminada. Para almacenar y tratar sus datos únicamente en la Unión Europea, debe definir explícitamente el endpoint (eu-vision.googleapis.com). En los siguientes ejemplos de código se muestra cómo configurar este ajuste.

   REST

   Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

   • REGION_ID: uno de los identificadores de ubicación regional válidos:
     • us: solo en EE. UU.
     • eu: la Unión Europea
   • CLOUD_STORAGE_IMAGE_URI: la ruta a un archivo de imagen válido en un segmento de Cloud Storage. Debe tener al menos privilegios de lectura en el archivo. Ejemplo:
     • gs://cloud-samples-data/vision/handwriting_image.png

   • PROJECT_ID: tu ID de proyecto Google Cloud .

   Método HTTP y URL:

   POST https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/images:annotate

   Cuerpo JSON de la solicitud:

   {
     "requests": [
       {
         "image": {
           "source": {
             "imageUri": "CLOUD_STORAGE_IMAGE_URI"
           }
          },
          "features": [
            {
              "type": "DOCUMENT_TEXT_DETECTION"
            }
          ]
       }
     ]
   }
   

   Para enviar tu solicitud, elige una de estas opciones:

   curl

   Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar la cuenta activa, ejecuta el comando gcloud auth list.

   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 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/images:annotate"

   PowerShell

   Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar la cuenta activa, ejecuta el comando gcloud auth list.

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

   $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/images:annotate" | Select-Object -Expand Content

   Si la solicitud se realiza de forma correcta, el servidor devuelve un código de estado HTTP 200 OK y la respuesta en formato JSON.

   Note: Zero coordinate values omitted. When the API detects a coordinate ("x" or "y") value of 0, that coordinate is omitted in the JSON response. Thus, a response with a bounding poly around the entire image would be
   [{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] for an image that is 100 pixels by 100 pixels. For more information, see the API Reference documentation.

   Respuesta

   {
     "responses": [
       {
         "textAnnotations": [
           {
             "locale": "en",
             "description": "O Google Cloud Platform\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 14,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 37
                 },
                 {
                   "x": 14,
                   "y": 37
                 }
               ]
             }
           },
         ],
         "fullTextAnnotation": {
           "pages": [
             {
               "property": {
                 "detectedLanguages": [
                   {
                     "languageCode": "en"
                   }
                 ]
               },
               "width": 281,
               "height": 44,
               "blocks": [
                 {
                   "property": {
                     "detectedLanguages": [
                       {
                         "languageCode": "en"
                       }
                     ]
                   },
                   "boundingBox": {
                     "vertices": [
                       {
                         "x": 14, "y": 11
                       },
                       {
                         "x": 279, "y": 11
                       },
                       {
                         "x": 279, "y": 37
                       },
                       {
                         "x": 14, "y": 37
                       }
                     ]
                   },
                   "paragraphs": [
                     {
                       "property": {
                         "detectedLanguages": [
                           {
                             "languageCode": "en"
                           }
                         ]
                       },
                       "boundingBox": {
                         "vertices": [
                           {
                             "x": 14, "y": 11
                           },
                           {
                             "x": 279, "y": 11
                           },
                           {
                             "x": 279, "y": 37
                           },
                           {
                             "x": 14, "y": 37
                           }
                         ]
                       },
                       "words": [
                         {
                           "property": {
                             "detectedLanguages": [
                               {
                                 "languageCode": "en"
                               }
                             ]
                           },
                           "boundingBox": {
                             "vertices": [
                               {
                                 "x": 14, "y": 11
                               },
                               {
                                 "x": 23, "y": 11
                               },
                               {
                                 "x": 23, "y": 37
                               },
                               {
                                 "x": 14, "y": 37
                               }
                             ]
                           },
                           "symbols": [
                             {
                               "property": {
                                 "detectedLanguages": [
                                   {
                                     "languageCode": "en"
                                   }
                                 ],
                                 "detectedBreak": {
                                   "type": "SPACE"
                                 }
                               },
                               "boundingBox": {
                                 "vertices": [
                                   {
                                     "x": 14, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 37
                                   },
                                   {
                                     "x": 14, "y": 37
                                   }
                                 ]
                               },
                               "text": "O"
                             }
                           ]
                         },
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 }
               ]
             }
           ],
           "text": "Google Cloud Platform\n"
         }
       }
     ]
   }
   

   Go

   Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

   Antes de probar este ejemplo, sigue las instrucciones de configuración de Java que se indican en la guía de inicio rápido de la API Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Vision en Java.

   Nota: Para los usuarios del framework Spring de Java, Spring Cloud Google Cloud ofrece una forma de configurar automáticamente los ajustes de autenticación y los objetos de cliente para usar la 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

   Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo 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

   Antes de probar este ejemplo, sigue las Python instrucciones de configuración de la guía de inicio rápido de Vision con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python Vision.

   Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

   from google.cloud import vision
   
   client_options = {"api_endpoint": "eu-vision.googleapis.com"}
   
   client = vision.ImageAnnotatorClient(client_options=client_options)

   Probar

   Prueba la detección de texto y la detección de texto en documentos con la siguiente herramienta. Puedes usar la imagen especificada (gs://cloud-samples-data/vision/handwriting_image.png) haciendo clic en Ejecutar o especificar tu propia imagen en su lugar.

   

   Cuerpo de la solicitud:

   {
     "requests": [
       {
         "features": [
           {
             "type": "DOCUMENT_TEXT_DETECTION"
           }
         ],
         "image": {
           "source": {
             "imageUri": "gs://cloud-samples-data/vision/handwriting_image.png"
           }
         }
       }
     ]
   }