Detecta escritura a mano en imágenes

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, el bloque, el párrafo, la palabra y la ruptura.

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

    Imagen de escritura a mano

Solicitudes de detección de texto en documentos

Configura tu proyecto de GCP y la autenticación

quickstart,gcloud_init vision.googleapis.com Cloud Vision API SERVICE_ACCOUNT True env_var

Detecta texto de documento en una imagen local

La API de Vision puede realizar una detección de características en un archivo de imagen local si envía los contenidos del archivo de imagen como una string codificada en base64 en el cuerpo de la solicitud.

LÍNEA DE CMD Y REST

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

  • base64-encoded-image: Es la representación en base64 (string ASCII) de los datos binarios de la imagen. 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.

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

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

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

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Si la solicitud se completa de manera correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

C#

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

// Load an image from a local file.
    var image = Image.FromFile(filePath);
    var client = ImageAnnotatorClient.Create();
    var response = client.DetectDocumentText(image);
    foreach (var page in response.Pages)
    {
        foreach (var block in page.Blocks)
        {
            foreach (var paragraph in block.Paragraphs)
            {
                Console.WriteLine(string.Join("\n", paragraph.Words));
            }
        }
    }

Go

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


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

public static void detectDocumentText(String filePath, PrintStream out) throws Exception,
         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);

      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();
        client.close();

        for (AnnotateImageResponse res : responses) {
          if (res.hasError()) {
            out.printf("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();
                    out.format("Symbol text: %s (confidence: %f)\n", symbol.getText(),
                        symbol.getConfidence());
                  }
                  out.format("Word text: %s (confidence: %f)\n\n", wordText, word.getConfidence());
                  paraText = String.format("%s %s", paraText, wordText);
                }
                // Output Example using Paragraph:
                out.println("\nParagraph: \n" + paraText);
                out.format("Paragraph Confidence: %f\n", para.getConfidence());
                blockText = blockText + paraText;
              }
              pageText = pageText + blockText;
            }
          }
          out.println("\nComplete annotation:");
          out.println(annotation.getText());
        }
      }
    }

Node.js

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


    // Imports the Google Cloud client 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}`);
            });
          });
        });
      });
    });

PHP

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

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

    // $path = 'path/to/your/image.jpg'

    function detect_document_text($path)
    {
        $imageAnnotator = new ImageAnnotatorClient();

        # annotate the image
        $image = file_get_contents($path);
        $response = $imageAnnotator->documentTextDetection($image);
        $annotation = $response->getFullTextAnnotation();

        # print out detailed and structured information about document text
        if ($annotation) {
            foreach ($annotation->getPages() as $page) {
                foreach ($page->getBlocks() as $block) {
                    $block_text = '';
                    foreach ($block->getParagraphs() as $paragraph) {
                        foreach ($paragraph->getWords() as $word) {
                            foreach ($word->getSymbols() as $symbol) {
                                $block_text .= $symbol->getText();
                            }
                            $block_text .= ' ';
                        }
                        $block_text .= "\n";
                    }
                    printf('Block content: %s', $block_text);
                    printf('Block confidence: %f' . PHP_EOL,
                        $block->getConfidence());

                    # get bounds
                    $vertices = $block->getBoundingBox()->getVertices();
                    $bounds = [];
                    foreach ($vertices as $vertex) {
                        $bounds[] = sprintf('(%d,%d)', $vertex->getX(),
                            $vertex->getY());
                    }
                    print('Bounds: ' . join(', ', $bounds) . PHP_EOL);
                    print(PHP_EOL);
                }
            }
        } else {
            print('No text found' . PHP_EOL);
        }

        $imageAnnotator->close();
    }

Python

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

def detect_document(path):
        """Detects document features in an image."""
        from google.cloud import vision
        import io
        client = vision.ImageAnnotatorClient()

        with io.open(path, 'rb') as image_file:
            content = image_file.read()

        image = vision.types.Image(content=content)

        response = client.document_text_detection(image=image)

        for page in response.full_text_annotation.pages:
            for block in page.blocks:
                print('\nBlock confidence: {}\n'.format(block.confidence))

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

Ruby

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

# image_path = "Path to local image file, eg. './image.png'"

    require "google/cloud/vision"

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

    response = image_annotator.document_text_detection image: image_path

    text = ""
    response.responses.each do |res|
      res.text_annotations.each do |annotation|
        text << annotation.description
      end
    end

    puts text

Detecta texto del documento en una imagen remota

Para tu comodidad, la API de Vision puede realizar una detección de características directamente en un archivo de imagen ubicado en Google Cloud Storage o en la Web, sin necesidad de enviar el contenido del archivo de imagen en el cuerpo de tu solicitud.

LÍNEA DE CMD Y REST

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

  • cloud-storage-image-uri: Es la ruta de acceso a un archivo de imagen válido en un depósito de Cloud Storage. Como mínimo, debes tener privilegios de lectura del archivo. Ejemplo:
    • gs://vision-api-handwriting-ocr-bucket/handwriting_image.png

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

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://vision.googleapis.com/v1/images:annotate

PowerShell

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

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Si la solicitud se completa de manera correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

C#

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

// Specify a Google Cloud Storage uri for the image
    // or a publicly accessible HTTP or HTTPS uri.
    var image = Image.FromUri(uri);
    var client = ImageAnnotatorClient.Create();
    var response = client.DetectDocumentText(image);
    foreach (var page in response.Pages)
    {
        foreach (var block in page.Blocks)
        {
            foreach (var paragraph in block.Paragraphs)
            {
                Console.WriteLine(string.Join("\n", paragraph.Words));
            }
        }
    }

Go

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


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

public static void detectDocumentTextGcs(String gcsPath, PrintStream out) throws Exception,
        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);

      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();
        client.close();

        for (AnnotateImageResponse res : responses) {
          if (res.hasError()) {
            out.printf("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();
                    out.format("Symbol text: %s (confidence: %f)\n", symbol.getText(),
                        symbol.getConfidence());
                  }
                  out.format("Word text: %s (confidence: %f)\n\n", wordText, word.getConfidence());
                  paraText = String.format("%s %s", paraText, wordText);
                }
                // Output Example using Paragraph:
                out.println("\nParagraph: \n" + paraText);
                out.format("Paragraph Confidence: %f\n", para.getConfidence());
                blockText = blockText + paraText;
              }
              pageText = pageText + blockText;
            }
          }
          out.println("\nComplete annotation:");
          out.println(annotation.getText());
        }
      }
    }

Node.js

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


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

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

PHP

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

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

    // $path = 'gs://path/to/your/image.jpg'

    function detect_document_text_gcs($path)
    {
        $imageAnnotator = new ImageAnnotatorClient();

        # annotate the image
        $response = $imageAnnotator->documentTextDetection($path);
        $annotation = $response->getFullTextAnnotation();

        # print out detailed and structured information about document text
        if ($annotation) {
            foreach ($annotation->getPages() as $page) {
                foreach ($page->getBlocks() as $block) {
                    $block_text = '';
                    foreach ($block->getParagraphs() as $paragraph) {
                        foreach ($paragraph->getWords() as $word) {
                            foreach ($word->getSymbols() as $symbol) {
                                $block_text .= $symbol->getText();
                            }
                            $block_text .= ' ';
                        }
                        $block_text .= "\n";
                    }
                    printf('Block content: %s', $block_text);
                    printf('Block confidence: %f' . PHP_EOL,
                        $block->getConfidence());

                    # get bounds
                    $vertices = $block->getBoundingBox()->getVertices();
                    $bounds = [];
                    foreach ($vertices as $vertex) {
                        $bounds[] = sprintf('(%d,%d)', $vertex->getX(),
                            $vertex->getY());
                    }
                    print('Bounds: ' . join(', ', $bounds) . PHP_EOL);

                    print(PHP_EOL);
                }
            }
        } else {
            print('No text found' . PHP_EOL);
        }

        $imageAnnotator->close();
    }

Python

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

def 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.types.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('\nBlock confidence: {}\n'.format(block.confidence))

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

Ruby

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

# image_path = "Google Cloud Storage URI, eg. 'gs://my-bucket/image.png'"

    require "google/cloud/vision"

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

    response = image_annotator.document_text_detection image: image_path

    text = ""
    response.responses.each do |res|
      res.text_annotations.each do |annotation|
        text << annotation.description
      end
    end

    puts text

Comando de 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://vision-api-handwriting-ocr-bucket/handwriting_image.png
    

Especifica el idioma (opcional)

Ambos tipos de solicitudes de OCR admiten uno o más languageHints que especifican el idioma de cualquier texto en la imagen. Sin embargo, en la mayoría de los casos, un valor vacío obtiene mejores resultados, ya que permite 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 admitidos.

Si decides proporcionar una sugerencia de idioma, modifica el cuerpo de la solicitud (archivo request.json) para proporcionar la string de uno de los idiomas admitidos en el campo imageContext.languageHints, como se muestra a continuación:

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

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

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

Ubicaciones

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

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

Configura la ubicación con la API

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

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

Configura la ubicación con las bibliotecas cliente

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

LÍNEA DE CMD Y REST

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

  • cloud-storage-image-uri: Es la ruta de acceso a un archivo de imagen válido en un depósito de Cloud Storage. Como mínimo, debes tener privilegios de lectura del archivo. Ejemplo:
    • gs://vision-api-handwriting-ocr-bucket/handwriting_image.png

Método HTTP y URL:

POST https://eu-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

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

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://eu-vision.googleapis.com/v1/images:annotate

PowerShell

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

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

Si la solicitud se completa de manera correcta, el servidor muestra un código de estado HTTP 200 OK y la respuesta en formato JSON.

C#

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

Go

import (
    	"context"
    	"fmt"

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

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

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

    	return nil
    }
    

Java

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

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

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

Node.js

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

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

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

PHP

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

    $client = new ImageAnnotatorClient($options);

Python

from google.cloud import vision

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

    client = vision.ImageAnnotatorClient(client_options=client_options)

Ruby

require "google/cloud/vision"

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

Pruébala

A continuación, prueba la detección de texto y la detección de texto en documentos. Puedes usar la imagen ya especificada (gs://vision-api-handwriting-ocr-bucket/handwriting_image.png) si haces clic en Ejecutar, o puedes especificar tu propia imagen en su lugar.

Imagen de escritura a mano