Detectar texto en imágenes

Si quieres detectar texto en documentos escaneados, prueba Document AI para el reconocimiento óptico de caracteres, el análisis de formularios estructurados y la extracción de entidades. Puedes usar Document AI Toolbox para convertir la salida del formato de Document AI al formato de Cloud Vision.

¿Vas a usar 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.

Reconocimiento óptico de caracteres (OCR)

La API Vision puede detectar y extraer texto de imágenes. Hay dos funciones de anotación que admiten el reconocimiento óptico de caracteres (OCR):

• TEXT_DETECTION detecta y extrae texto de cualquier imagen. Por ejemplo, una fotografía puede contener una señal de tráfico o un cartel de una calle. El JSON incluye toda la cadena extraída, así como palabras individuales y sus cuadros delimitadores.

  

• DOCUMENT_TEXT_DETECTION también extrae texto de una imagen, pero 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.

  

  Consulta más información sobre DOCUMENT_TEXT_DETECTION para la extracción de escritura a mano y la extracción de texto de archivos (PDF o TIFF).

Solicitudes de detección de texto

Nota: 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.

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 en una imagen local

   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.

   gcloud

   Para detectar texto, usa el comando gcloud ml vision detect-text como se muestra en el siguiente ejemplo:

   gcloud ml vision detect-text ./path/to/local/file.jpg
   

   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": "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.

   Una respuesta TEXT_DETECTION incluye la frase detectada, su cuadro delimitador y las palabras individuales con sus cuadros delimitadores.

   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": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 341,
                   "y": 828
                 },
                 {
                   "x": 2249,
                   "y": 828
                 },
                 {
                   "x": 2249,
                   "y": 1993
                 },
                 {
                   "x": 341,
                   "y": 1993
                 }
               ]
             }
           },
           {
             "description": "WAITING?",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 352,
                   "y": 828
                 },
                 {
                   "x": 2248,
                   "y": 911
                 },
                 {
                   "x": 2238,
                   "y": 1148
                 },
                 {
                   "x": 342,
                   "y": 1065
                 }
               ]
             }
           },
           {
             "description": "PLEASE",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1210,
                   "y": 1233
                 },
                 {
                   "x": 1907,
                   "y": 1263
                 },
                 {
                   "x": 1902,
                   "y": 1383
                 },
                 {
                   "x": 1205,
                   "y": 1353
                 }
               ]
             }
           },
           {
             "description": "TURN",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1210,
                   "y": 1418
                 },
                 {
                   "x": 1730,
                   "y": 1441
                 },
                 {
                   "x": 1724,
                   "y": 1564
                 },
                 {
                   "x": 1205,
                   "y": 1541
                 }
               ]
             }
           },
           {
             "description": "OFF",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1792,
                   "y": 1443
                 },
                 {
                   "x": 2128,
                   "y": 1458
                 },
                 {
                   "x": 2122,
                   "y": 1581
                 },
                 {
                   "x": 1787,
                   "y": 1566
                 }
               ]
             }
           },
           {
             "description": "YOUR",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1219,
                   "y": 1603
                 },
                 {
                   "x": 1746,
                   "y": 1629
                 },
                 {
                   "x": 1740,
                   "y": 1759
                 },
                 {
                   "x": 1213,
                   "y": 1733
                 }
               ]
             }
           },
           {
             "description": "ENGINE",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1222,
                   "y": 1771
                 },
                 {
                   "x": 1944,
                   "y": 1834
                 },
                 {
                   "x": 1930,
                   "y": 1992
                 },
                 {
                   "x": 1208,
                   "y": 1928
                 }
               ]
             }
           }
         ],
         "fullTextAnnotation": {
           "pages": [
                     ...
                     ]
                   },
                   "paragraphs": [
                         ...
                         ]
                       },
                       "words": [
                           ...
                           },
                           "symbols": [
                           ...
                         }
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 },
                 ...
               ]
             }
           ],
           "text": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\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.

   
   // detectText gets text from the Vision API for an image at the given file path.
   func detectText(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
   	}
   	annotations, err := client.DetectTexts(ctx, image, nil, 10)
   	if err != nil {
   		return err
   	}
   
   	if len(annotations) == 0 {
   		fmt.Fprintln(w, "No text found.")
   	} else {
   		fmt.Fprintln(w, "Text:")
   		for _, annotation := range annotations {
   			fmt.Fprintf(w, "%q\n", annotation.Description)
   		}
   	}
   
   	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.

   
   import com.google.cloud.vision.v1.AnnotateImageRequest;
   import com.google.cloud.vision.v1.AnnotateImageResponse;
   import com.google.cloud.vision.v1.BatchAnnotateImagesResponse;
   import com.google.cloud.vision.v1.EntityAnnotation;
   import com.google.cloud.vision.v1.Feature;
   import com.google.cloud.vision.v1.Image;
   import com.google.cloud.vision.v1.ImageAnnotatorClient;
   import com.google.protobuf.ByteString;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.List;
   
   public class DetectText {
     public static void detectText() throws IOException {
       // TODO(developer): Replace these variables before running the sample.
       String filePath = "path/to/your/image/file.jpg";
       detectText(filePath);
     }
   
     // Detects text in the specified image.
     public static void detectText(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(Feature.Type.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();
   
         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
           for (EntityAnnotation annotation : res.getTextAnnotationsList()) {
             System.out.format("Text: %s%n", annotation.getDescription());
             System.out.format("Position : %s%n", annotation.getBoundingPoly());
           }
         }
       }
     }
   }

   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.

   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';
   
   // Performs text detection on the local file
   const [result] = await client.textDetection(fileName);
   const detections = result.textAnnotations;
   console.log('Text:');
   detections.forEach(text => console.log(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_text(path):
       """Detects text in the file."""
       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.text_detection(image=image)
       texts = response.text_annotations
       print("Texts:")
   
       for text in texts:
           print(f'\n"{text.description}"')
   
           vertices = [
               f"({vertex.x},{vertex.y})" for vertex in text.bounding_poly.vertices
           ]
   
           print("bounds: {}".format(",".join(vertices)))
   
       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 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.

   gcloud

   Para detectar texto, usa el comando gcloud ml vision detect-text como se muestra en el siguiente ejemplo:

   gcloud ml vision detect-text gs://cloud-samples-data/vision/ocr/sign.jpg
   

   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/ocr/sign.jpg

   • 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": "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.

   Una respuesta TEXT_DETECTION incluye la frase detectada, su cuadro delimitador y las palabras individuales con sus cuadros delimitadores.

   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": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 341,
                   "y": 828
                 },
                 {
                   "x": 2249,
                   "y": 828
                 },
                 {
                   "x": 2249,
                   "y": 1993
                 },
                 {
                   "x": 341,
                   "y": 1993
                 }
               ]
             }
           },
           {
             "description": "WAITING?",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 352,
                   "y": 828
                 },
                 {
                   "x": 2248,
                   "y": 911
                 },
                 {
                   "x": 2238,
                   "y": 1148
                 },
                 {
                   "x": 342,
                   "y": 1065
                 }
               ]
             }
           },
           {
             "description": "PLEASE",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1210,
                   "y": 1233
                 },
                 {
                   "x": 1907,
                   "y": 1263
                 },
                 {
                   "x": 1902,
                   "y": 1383
                 },
                 {
                   "x": 1205,
                   "y": 1353
                 }
               ]
             }
           },
           {
             "description": "TURN",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1210,
                   "y": 1418
                 },
                 {
                   "x": 1730,
                   "y": 1441
                 },
                 {
                   "x": 1724,
                   "y": 1564
                 },
                 {
                   "x": 1205,
                   "y": 1541
                 }
               ]
             }
           },
           {
             "description": "OFF",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1792,
                   "y": 1443
                 },
                 {
                   "x": 2128,
                   "y": 1458
                 },
                 {
                   "x": 2122,
                   "y": 1581
                 },
                 {
                   "x": 1787,
                   "y": 1566
                 }
               ]
             }
           },
           {
             "description": "YOUR",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1219,
                   "y": 1603
                 },
                 {
                   "x": 1746,
                   "y": 1629
                 },
                 {
                   "x": 1740,
                   "y": 1759
                 },
                 {
                   "x": 1213,
                   "y": 1733
                 }
               ]
             }
           },
           {
             "description": "ENGINE",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1222,
                   "y": 1771
                 },
                 {
                   "x": 1944,
                   "y": 1834
                 },
                 {
                   "x": 1930,
                   "y": 1992
                 },
                 {
                   "x": 1208,
                   "y": 1928
                 }
               ]
             }
           }
         ],
         "fullTextAnnotation": {
           "pages": [
                     ...
                     ]
                   },
                   "paragraphs": [
                         ...
                         ]
                       },
                       "words": [
                           ...
                           },
                           "symbols": [
                           ...
                         }
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 },
                 ...
               ]
             }
           ],
           "text": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\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.

   
   // detectText gets text from the Vision API for an image at the given file path.
   func detectTextURI(w io.Writer, file string) error {
   	ctx := context.Background()
   
   	client, err := vision.NewImageAnnotatorClient(ctx)
   	if err != nil {
   		return err
   	}
   
   	image := vision.NewImageFromURI(file)
   	annotations, err := client.DetectTexts(ctx, image, nil, 10)
   	if err != nil {
   		return err
   	}
   
   	if len(annotations) == 0 {
   		fmt.Fprintln(w, "No text found.")
   	} else {
   		fmt.Fprintln(w, "Text:")
   		for _, annotation := range annotations {
   			fmt.Fprintf(w, "%q\n", annotation.Description)
   		}
   	}
   
   	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.

   
   import com.google.cloud.vision.v1.AnnotateImageRequest;
   import com.google.cloud.vision.v1.AnnotateImageResponse;
   import com.google.cloud.vision.v1.BatchAnnotateImagesResponse;
   import com.google.cloud.vision.v1.EntityAnnotation;
   import com.google.cloud.vision.v1.Feature;
   import com.google.cloud.vision.v1.Image;
   import com.google.cloud.vision.v1.ImageAnnotatorClient;
   import com.google.cloud.vision.v1.ImageSource;
   import java.io.IOException;
   import java.util.ArrayList;
   import java.util.List;
   
   public class DetectTextGcs {
   
     public static void detectTextGcs() throws IOException {
       // TODO(developer): Replace these variables before running the sample.
       String filePath = "gs://your-gcs-bucket/path/to/image/file.jpg";
       detectTextGcs(filePath);
     }
   
     // Detects text in the specified remote image on Google Cloud Storage.
     public static void detectTextGcs(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(Feature.Type.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();
   
         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
           for (EntityAnnotation annotation : res.getTextAnnotationsList()) {
             System.out.format("Text: %s%n", annotation.getDescription());
             System.out.format("Position : %s%n", annotation.getBoundingPoly());
           }
         }
       }
     }
   }

   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';
   
   // Performs text detection on the gcs file
   const [result] = await client.textDetection(`gs://${bucketName}/${fileName}`);
   const detections = result.textAnnotations;
   console.log('Text:');
   detections.forEach(text => console.log(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_text_uri(uri):
       """Detects text in the file located in Google Cloud Storage or on the Web."""
       from google.cloud import vision
   
       client = vision.ImageAnnotatorClient()
       image = vision.Image()
       image.source.image_uri = uri
   
       response = client.text_detection(image=image)
       texts = response.text_annotations
       print("Texts:")
   
       for text in texts:
           print(f'\n"{text.description}"')
   
           vertices = [
               f"({vertex.x},{vertex.y})" for vertex in text.bounding_poly.vertices
           ]
   
           print("bounds: {}".format(",".join(vertices)))
   
       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.

   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/ocr/sign.jpg

   • 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": "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.

   Una respuesta TEXT_DETECTION incluye la frase detectada, su cuadro delimitador y las palabras individuales con sus cuadros delimitadores.

   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": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 341,
                   "y": 828
                 },
                 {
                   "x": 2249,
                   "y": 828
                 },
                 {
                   "x": 2249,
                   "y": 1993
                 },
                 {
                   "x": 341,
                   "y": 1993
                 }
               ]
             }
           },
           {
             "description": "WAITING?",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 352,
                   "y": 828
                 },
                 {
                   "x": 2248,
                   "y": 911
                 },
                 {
                   "x": 2238,
                   "y": 1148
                 },
                 {
                   "x": 342,
                   "y": 1065
                 }
               ]
             }
           },
           {
             "description": "PLEASE",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1210,
                   "y": 1233
                 },
                 {
                   "x": 1907,
                   "y": 1263
                 },
                 {
                   "x": 1902,
                   "y": 1383
                 },
                 {
                   "x": 1205,
                   "y": 1353
                 }
               ]
             }
           },
           {
             "description": "TURN",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1210,
                   "y": 1418
                 },
                 {
                   "x": 1730,
                   "y": 1441
                 },
                 {
                   "x": 1724,
                   "y": 1564
                 },
                 {
                   "x": 1205,
                   "y": 1541
                 }
               ]
             }
           },
           {
             "description": "OFF",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1792,
                   "y": 1443
                 },
                 {
                   "x": 2128,
                   "y": 1458
                 },
                 {
                   "x": 2122,
                   "y": 1581
                 },
                 {
                   "x": 1787,
                   "y": 1566
                 }
               ]
             }
           },
           {
             "description": "YOUR",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1219,
                   "y": 1603
                 },
                 {
                   "x": 1746,
                   "y": 1629
                 },
                 {
                   "x": 1740,
                   "y": 1759
                 },
                 {
                   "x": 1213,
                   "y": 1733
                 }
               ]
             }
           },
           {
             "description": "ENGINE",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 1222,
                   "y": 1771
                 },
                 {
                   "x": 1944,
                   "y": 1834
                 },
                 {
                   "x": 1930,
                   "y": 1992
                 },
                 {
                   "x": 1208,
                   "y": 1928
                 }
               ]
             }
           }
         ],
         "fullTextAnnotation": {
           "pages": [
                     ...
                     ]
                   },
                   "paragraphs": [
                         ...
                         ]
                       },
                       "words": [
                           ...
                           },
                           "symbols": [
                           ...
                         }
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 },
                 ...
               ]
             }
           ],
           "text": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\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 las funciones de detección de texto y detección de texto en documentos que se indican a continuación. Puedes usar la imagen especificada (gs://cloud-samples-data/vision/ocr/sign.jpg) haciendo clic en Ejecutar o especificar tu propia imagen en su lugar.

   Para probar la detección de texto en documentos, actualiza el valor de type a DOCUMENT_TEXT_DETECTION.

   

   Cuerpo de la solicitud:

   {
     "requests": [
       {
         "features": [
           {
             "type": "TEXT_DETECTION"
           }
         ],
         "image": {
           "source": {
             "imageUri": "gs://cloud-samples-data/vision/ocr/sign.jpg"
           }
         }
       }
     ]
   }