Detecta escritura a mano en imágenes

Nota:

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

El precio de la detección de texto del documento es de DOCUMENT_TEXT_DETECTION. Consulta la página de Precios para obtener más detalles.

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

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

• DOCUMENT_TEXT_DETECTION extrae texto de una imagen (o archivo); la respuesta está optimizada para texto denso y documentos. JSON incluye la información de la página, del bloque, del párrafo, la palabra y la ruptura.

  

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

  

Pruébalo tú mismo

Si es la primera vez que usas Google Cloud, crea una cuenta para evaluar el rendimiento de API de Cloud Vision en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Prueba gratis la API de Cloud Vision

Solicitudes de detección de texto en documentos

Configura el proyecto de Google Cloud y la autenticación

Si no has creado un proyecto de Google Cloud, hazlo ahora. Expande esta sección para obtener instrucciones.

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

   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

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Vision API.

   Enable the API

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

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

   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

8. Make sure that billing is enabled for your Google Cloud project.

9. Enable the Vision API.

   Enable the API

10. Install the Google Cloud CLI.

11. To initialize the gcloud CLI, run the following command:

    gcloud init

Detecta texto de documento en una imagen local

Puedes usar la API de Vision para realizar la detección de características en un archivo de imagen local.

Para las solicitudes de REST, envía el contenido del archivo de imagen como una string codificada en base64 en el cuerpo de tu solicitud.

Para las solicitudes de biblioteca cliente y gcloud, especifica la ruta a una imagen local en tu solicitud.

REST

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

• BASE64_ENCODED_IMAGE: Es la representación en base64 (string ASCII) de los datos de la imagen binaria. Esta string debería ser similar a la siguiente:
  • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
  Visita Codificación en base64 para obtener más información.
• PROJECT_ID es el ID del proyecto de 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: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta 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: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta 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 completa de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

Nota: Valores de coordenadas cero omitidos. Cuando la API detecta un valor de coordenada (“x” o “y”) de 0, esa coordenada se omite en la respuesta JSON. Por lo tanto, una respuesta con un polígono límite alrededor de toda la imagen sería
[{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] para una imagen que tenga 100 píxeles por 100 píxeles. Para obtener más información, consulta la documentación de referencia de la API.

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

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 código de muestra, sigue las instrucciones de configuración para Java que se encuentran la Guía de inicio rápido de la API de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Java.

Nota: Si eres un usuario del framework de Spring de Java, Spring Cloud Google Cloud te ofrece una manera de establecer de forma automática la configuración de la autenticación y los objetos cliente para usar la API de 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 código de muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la Guía de inicio rápido de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Node.js.

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 código de muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Python.

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 lasinstrucciones de configuración de C# en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Vision para .NET.

PHP: sigue las instrucciones de configuración de PHP en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Vision para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Vision para Ruby.

Detecta texto del documento en una imagen remota

Puedes usar la API de Vision para realizar funciones de detección de características en un archivo de imagen remoto ubicado en Cloud Storage o en la Web. Para enviar una solicitud de archivo remoto, especifica la URL web del archivo o el URI de Cloud Storage en el cuerpo de la solicitud.

Precaución: Cuando se recuperan imágenes de URL HTTP/HTTPS, Google no puede garantizar que se completará la solicitud. Tu solicitud puede fallar si el host especificado la niega (por ejemplo, debido a una regulación de solicitud o a una prevención de DoS), o si Google limita las solicitudes al sitio para evitar abusos. Como práctica recomendada, no dependas de las imágenes alojadas de forma externa para las aplicaciones de producción.

REST

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

• CLOUD_STORAGE_IMAGE_URI: La ruta 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/handwriting_image.png

• PROJECT_ID es el ID del proyecto de 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: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta 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: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta 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 completa de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

Nota: Valores de coordenadas cero omitidos. Cuando la API detecta un valor de coordenada (“x” o “y”) de 0, esa coordenada se omite en la respuesta JSON. Por lo tanto, una respuesta con un polígono límite alrededor de toda la imagen sería
[{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] para una imagen que tenga 100 píxeles por 100 píxeles. Para obtener más información, consulta la documentación de referencia de la API.

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

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 código de muestra, sigue las instrucciones de configuración para Java que se encuentran la Guía de inicio rápido de la API de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Java.

Nota: Si eres un usuario del framework de Spring de Java, Spring Cloud Google Cloud te ofrece una manera de establecer de forma automática la configuración de la autenticación y los objetos cliente para usar la API de 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 código de muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la Guía de inicio rápido de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Node.js.

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 código de muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Python.

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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

Si quieres realizar una detección de 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 lasinstrucciones de configuración de C# en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Vision para .NET.

PHP: sigue las instrucciones de configuración de PHP en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Vision para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página Bibliotecas cliente y, luego, visita la documentación de referencia de Vision para Ruby.

Especifica el idioma (opcional)

Ambos tipos de solicitudes de OCR admiten una o más languageHints que especifican el idioma de cualquier texto en la imagen. Sin embargo, un valor vacío suele producir los mejores resultados, ya que omitir un valor habilita la detección automática del idioma. Para los idiomas que se basan en el alfabeto latino, no es necesario configurar languageHints. En casos excepcionales, cuando se conoce el idioma del texto de la imagen, configurar una sugerencia ayuda a obtener mejores resultados (aunque puede ser un impedimento significativo si la sugerencia es incorrecta). La detección de texto muestra un error si uno o más de los idiomas especificados no es uno de los idiomas compatibles.

Si decides proporcionar una sugerencia de idioma, modifica el cuerpo de la solicitud (archivo request.json) para suministrar la string de uno de los idiomas compatibles en el campo imageContext.languageHints, como se indica en la siguiente muestra:

{
  "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 los lineamientos de formato del código de idioma BCP47. El formato especificado en 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), la transformación del singleton de extensión (t), el código de extensión (i0) de la transformación del motor de método de entrada y el código de transformación de escritura a mano (handwrit). Este código dice que el idioma es “Inglés transformado de la escritura a mano”. No es necesario especificar un código de secuencia de comandos porque Latn está implícito en el idioma "en".

Compatibilidad multirregional

En este momento, esta función solo se aplica a la característica de OCR (tipos TEXT_DETECTION o DOCUMENT_TEXT_DETECTION).

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 los 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á los 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

La API de Vision admite un extremo de API global (vision.googleapis.com) y también dos extremos basados en regiones: un extremo de la Unión Europea (eu-vision.googleapis.com) y un extremo de Estados Unidos (us-vision.googleapis.com). Usa estos extremos para el procesamiento específico de la región. Por ejemplo, para almacenar y procesar los 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/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 procesar tus datos solo en Estados Unidos, usa el extremo de EE. UU. (us-vision.googleapis.com) con los métodos anteriores.

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.

REST

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

• REGION_ID: Uno de los identificadores de ubicación regional válidos:
  • us: Solo países de EE.UU.
  • eu: La Unión Europea
• CLOUD_STORAGE_IMAGE_URI: La ruta 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/handwriting_image.png

• PROJECT_ID es el ID del proyecto de 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: Con el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login, o a través del uso de Cloud Shell, que accede de forma automática a la CLI de gcloud. Para comprobar la cuenta activa actual, ejecuta 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: En el siguiente comando, se supone que accediste a la CLI de gcloud con tu cuenta de usuario a través de la ejecución de gcloud init o gcloud auth login . Para comprobar la cuenta activa actual, ejecuta 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 completa de forma correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

Nota: Valores de coordenadas cero omitidos. Cuando la API detecta un valor de coordenada (“x” o “y”) de 0, esa coordenada se omite en la respuesta JSON. Por lo tanto, una respuesta con un polígono límite alrededor de toda la imagen sería
[{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] para una imagen que tenga 100 píxeles por 100 píxeles. Para obtener más información, consulta la documentación de referencia de la API.

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

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 código de muestra, sigue las instrucciones de configuración para Java que se encuentran la Guía de inicio rápido de la API de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Java.

Nota: Si eres un usuario del framework de Spring de Java, Spring Cloud Google Cloud te ofrece una manera de establecer de forma automática la configuración de la autenticación y los objetos cliente para usar la API de 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 código de muestra, sigue las instrucciones de configuración para Node.js que se encuentran en la Guía de inicio rápido de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Node.js.

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 código de muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de Vision sobre cómo usar las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Vision para Python.

Para autenticarte en Vision, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 en la siguiente herramienta. Puedes usar la imagen ya especificada (gs://cloud-samples-data/vision/handwriting_image.png) si haces clic en Ejecutar, o puedes 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"
        }
      }
    }
  ]
}