Traduce texto de una foto

En esta página, se muestra cómo detectar texto en una imagen, personalizar traducciones y generar voz sintética a partir de texto. En este instructivo, se usa Cloud Vision para detectar texto en un archivo de imagen. Luego, se muestra cómo usar Cloud Translation para proporcionar una traducción personalizada del texto detectado. Por último, se usa Text-to-Speech para proporcionar un dictado automático del texto traducido.

Objetivos

Pasar el texto reconocido por la API de Cloud Vision a la API de Cloud Translation
Crear y usar glosarios de Cloud Translation para personalizar las traducciones de la API de Cloud Translation
Crear una representación de audio del texto traducido con la API de Text-to-Speech

Costos

Cada API de Google Cloud usa una estructura de precios diferente.

Para obtener detalles sobre los precios, consulta la guía de precios de Cloud Vision, la guía de precios de Cloud Translation y la guía de precios de Text-to-Speech.

Antes de comenzar

Asegúrate de tener lo siguiente:

Un proyecto en Google Cloud Console con la API de Vision, la API de Cloud Translation y la API de Text-to-Speech habilitadas
Conocimiento básico sobre programación en Python o NodeJS

Configura bibliotecas cliente

En este instructivo, se usan bibliotecas cliente de Vision, Translation y Text-to-Speech.

Para instalar las bibliotecas cliente relevantes, ejecuta los siguientes comandos desde la terminal.

Python

  pip install --upgrade google-cloud-vision
  pip install --upgrade google-cloud-translate
  pip install --upgrade google-cloud-texttospeech

Node.js

  npm install --save @google-cloud/vision
  npm install --save @google-cloud/translate
  npm install --save @google-cloud/text-to-speech

Configura los permisos para la creación del glosario

La creación de glosarios en Translation requiere el uso de una clave de cuenta de servicio con permisos de “editor de la API de Cloud Translation”.

Para configurar una clave de cuenta de servicio con permisos de editor de la API de Cloud Translation, haz lo siguiente:

Crear una cuenta de servicio:
1. En la consola de Google Cloud, ve a la página Cuentas de servicio.
  
  Ir a Cuentas de servicio
2. Selecciona tu proyecto.
3. Haz clic en Crear cuenta de servicio.
4. Ingresa un nombre en el campo Nombre de cuenta de servicio. La consola de Google Cloud completa el campo ID de cuenta de servicio según este nombre.
5. Opcional: En el campo Descripción de la cuenta de servicio, ingresa una descripción para la cuenta de servicio.
6. Haz clic en Crear y continuar.
7. Haz clic en el campo Seleccionar una función y selecciona Cloud Translation > Editor de la API de Cloud Translation.
8. Haz clic en Listo para terminar de crear la cuenta de servicio.
  
  No cierres la ventana del navegador. La usarás en la próxima tarea.
Descarga una clave JSON para la cuenta de servicio que acabas de crear:
1. En la consola de Google Cloud, haz clic en la dirección de correo electrónico de la cuenta de servicio que creaste.
2. Haga clic en Claves.
3. Haz clic en Agregar clave, luego haz clic en Crear clave nueva.
4. Haga clic en Crear. Se descargará un archivo de claves JSON en tu computadora.
  
  Asegúrate de almacenar el archivo de claves de forma segura, ya que se puede usar para autenticarse como tu cuenta de servicio. Puedes mover y cambiar el nombre de este archivo como desees.
5. Haga clic en Cerrar.
En tu terminal, configura la variable GOOGLE_APPLICATION_CREDENTIALS con el siguiente comando. Reemplaza path_to_key por la ruta al archivo JSON descargado que contiene la nueva clave de la cuenta de servicio.
Linux o macOS
```
export GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```
Windows
```
set GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```

Importa bibliotecas

En este instructivo, se usan las siguientes importaciones del sistema y las importaciones de la biblioteca cliente.

Python

Antes de probar este ejemplo, sigue las instrucciones de configuración para Python que encontrarás en la guía de inicio rápido de Cloud Translation sobre las bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Python.

Para autenticarte en Cloud Translation, 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 html
import os

# Imports the Google Cloud client libraries
from google.api_core.exceptions import AlreadyExists
from google.cloud import texttospeech
from google.cloud import translate_v3beta1 as translate
from google.cloud import vision

Node.js

Antes de probar este ejemplo, sigue las instrucciones de configuración para Node.js que encontrarás en la guía de inicio rápido de Cloud Translation sobre las bibliotecas cliente. Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Node.js.

// Imports the Google Cloud client library
const textToSpeech = require('@google-cloud/text-to-speech');
const translate = require('@google-cloud/translate').v3beta1;
const vision = require('@google-cloud/vision');

// Import other required libraries
const fs = require('fs');
//const escape = require('escape-html');
const util = require('util');

Configura el ID del proyecto

Debes asociar un proyecto de Google Cloud con cada solicitud a una API de Google Cloud. Designa tu proyecto de Google Cloud mediante la configuración de la variable de entorno GCLOUD_PROJECT desde la terminal.

En el siguiente comando, reemplaza project-id por el ID de tu proyecto de Google Cloud. Ejecuta el siguiente comando desde la terminal.

Linux o macOS

export GCLOUD_PROJECT=project-id

Windows

set GCLOUD_PROJECT=project-id

Usa Vision para detectar texto de una imagen

Usa la API de Vision para detectar y extraer texto de una imagen. La API de Vision usa reconocimiento óptico de caracteres (OCR) para admitir dos funciones de detección de texto: detección de texto denso, o DOCUMENT_TEXT_DETECTION, y detección de texto disperso, o TEXT_DETECTION.

En el siguiente código, se muestra cómo usar la función DOCUMENT_TEXT_DETECTION de la API de Vision para detectar el texto de una foto con texto denso.

Python

def pic_to_text(infile: str) -> str:
    """Detects text in an image file

    Args:
    infile: path to image file

    Returns:
    String of text detected in image
    """

    # Instantiates a client
    client = vision.ImageAnnotatorClient()

    # Opens the input image file
    with open(infile, "rb") as image_file:
        content = image_file.read()

    image = vision.Image(content=content)

    # For dense text, use document_text_detection
    # For less dense text, use text_detection
    response = client.document_text_detection(image=image)
    text = response.full_text_annotation.text
    print(f"Detected text: {text}")

    return text

Node.js

/**
 * Detects text in an image file
 *
 * ARGS
 * inputFile: path to image file
 * RETURNS
 * string of text detected in the input image
 **/
async function picToText(inputFile) {
  // Creates a client
  const client = new vision.ImageAnnotatorClient();

  // Performs text detection on the local file
  const [result] = await client.textDetection(inputFile);
  return result.fullTextAnnotation.text;
}

Usa Translation con glosarios

Después de extraer texto de una imagen, usa los glosarios de Translation para personalizar la traducción del texto extraído. Los glosarios proporcionan traducciones predefinidas que anulan las traducciones de la API de Cloud Translation de los términos designados.

Entre los casos prácticos de los glosarios se incluyen los siguientes:

Nombres de productos: Por ejemplo, “Google Home” debe traducirse como “Google Home”.
Palabras ambiguas: Por ejemplo, la palabra “banco” puede referirse a un asiento o a una empresa dedicada a realizar operaciones financieras. Si sabes que traduces palabras del ámbito financiero, te recomendamos usar un glosario que proporcione a la API de Cloud Translation la traducción de “banco” correspondiente a ese ámbito y no la traducción referida al asiento.
Préstamos léxicos: Por ejemplo, la palabra francesa “bouillabaisse” se traduce como “bouillabaisse” en inglés; el idioma inglés tomó prestada la palabra “bouillabaisse” del idioma francés. Un hablante de inglés que carece de contexto cultural francés puede no saber que “bouillabaisse” es un guiso de pescado. Los glosarios pueden anular una traducción, de modo que “bouillabaisse” en francés se traduzca como “fish stew” (guiso de pescado) en inglés.

Crea un archivo de glosario

La API de Cloud Translation acepta archivos de glosario TSV, CSV o TMX. En este instructivo, se usa un archivo CSV subido a Cloud Storage para definir conjuntos de términos equivalentes.

Para crear un archivo de glosario CSV, sigue estos pasos:

Designa el idioma de una columna mediante códigos de idioma ISO-639 o BCP-47 en la primera fila del archivo CSV.
```
fr,en,
```
Enumera pares de términos equivalentes en cada fila del archivo CSV. Separa los términos con comas. En el siguiente ejemplo, se define la traducción al inglés de varias palabras francesas del ámbito culinario.
```
fr,en,
chèvre,goat cheese,
crème brulée,crème brulée,
bouillabaisse,fish stew,
steak frites,steak with french fries,
```

Define las variantes de una palabra. La API de Cloud Translation distingue mayúsculas de minúsculas y es sensible a los caracteres especiales, como las palabras acentuadas. Asegúrate de que tu glosario se ocupe de las variaciones de una palabra mediante la definición explícita de las distintas formas de escribir la palabra.

fr,en,
chevre,goat cheese,
Chevre,Goat cheese,
chèvre,goat cheese,
Chèvre,Goat cheese,
crème brulée,crème brulée,
Crème brulée,Crème brulée,
Crème Brulée,Crème Brulée,
bouillabaisse,fish stew,
Bouillabaisse,Fish stew,
steak frites,steak with french fries,
Steak frites,Steak with french fries,
Steak Frites,Steak with French Fries,

Sube el glosario a un depósito de Cloud Storage. Para los fines de este instructivo, no es necesario subir un archivo de glosario a un bucket de Cloud Storage ni crear un bucket de Cloud Storage. En cambio, usa el archivo de glosario de acceso público que se creó para este instructivo a fin de evitar generar costos de Cloud Storage. Envía el URI de un archivo de glosario en Cloud Storage a la API de Cloud Translation para crear un recurso de glosario. El URI del archivo de glosario disponible de manera pública para este instructivo es gs://cloud-samples-data/translation/bistro_glossary.csv. Para descargar el glosario, haz clic en el vínculo del URI anterior, pero no lo abras en una pestaña nueva.

Crea un recurso de glosario

Para usar un glosario, debes crear un recurso de glosario con la API de Cloud Translation. Para crear un recurso de glosario, envía el URI de un archivo de glosario en Cloud Storage a la API de Cloud Translation.

Asegúrate de usar una clave de cuenta de servicio con permisos de “editor de la API de Cloud Translation” y asegúrate de haber configurado tu ID del proyecto desde la terminal.

Con la siguiente función, se crea un recurso de glosario. Con este recurso del glosario, puedes personalizar la solicitud de traducción en el siguiente paso de este instructivo.

Python

def create_glossary(
    languages: list,
    project_id: str,
    glossary_name: str,
    glossary_uri: str,
) -> str:
    """Creates a GCP glossary resource
    Assumes you've already manually uploaded a glossary to Cloud Storage

    Args:
    languages: list of languages in the glossary
    project_id: GCP project id
    glossary_name: name you want to give this glossary resource
    glossary_uri: the uri of the glossary you uploaded to Cloud Storage

    Returns:
    name of the created or existing glossary
    """

    # Instantiates a client
    client = translate.TranslationServiceClient()

    # Designates the data center location that you want to use
    location = "us-central1"

    # Set glossary resource name
    name = client.glossary_path(project_id, location, glossary_name)

    # Set language codes
    language_codes_set = translate.Glossary.LanguageCodesSet(language_codes=languages)

    gcs_source = translate.GcsSource(input_uri=glossary_uri)

    input_config = translate.GlossaryInputConfig(gcs_source=gcs_source)

    # Set glossary resource information
    glossary = translate.Glossary(
        name=name, language_codes_set=language_codes_set, input_config=input_config
    )

    parent = f"projects/{project_id}/locations/{location}"

    # Create glossary resource
    # Handle exception for case in which a glossary
    #  with glossary_name already exists
    try:
        operation = client.create_glossary(parent=parent, glossary=glossary)
        operation.result(timeout=90)
        print("Created glossary " + glossary_name + ".")
    except AlreadyExists:
        print(
            "The glossary "
            + glossary_name
            + " already exists. No new glossary was created."
        )

    return glossary_name

Node.js

/** Creates a GCP glossary resource
 * Assumes you've already manually uploaded a glossary to Cloud Storage
 *
 * ARGS
 * languages: list of languages in the glossary
 * projectId: GCP project id
 * glossaryName: name you want to give this glossary resource
 * glossaryUri: the uri of the glossary you uploaded to Cloud Storage
 * RETURNS
 * nothing
 **/
async function createGlossary(
  languages,
  projectId,
  glossaryName,
  glossaryUri
) {
  // Instantiates a client
  const translationClient = await new translate.TranslationServiceClient();

  // Construct glossary
  const glossary = {
    languageCodesSet: {
      languageCodes: languages,
    },
    inputConfig: {
      gcsSource: {
        inputUri: glossaryUri,
      },
    },
    name: translationClient.glossaryPath(
      projectId,
      'us-central1',
      glossaryName
    ),
  };

  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, 'us-central1'),
    glossary: glossary,
  };

  // Create glossary using a long-running operation.
  try {
    const [operation] = await translationClient.createGlossary(request);
    // Wait for operation to complete.
    await operation.promise();
    console.log('Created glossary ' + glossaryName + '.');
  } catch (AlreadyExists) {
    console.log(
      'The glossary ' +
        glossaryName +
        ' already exists. No new glossary was created.'
    );
  }
}

Traduce con glosarios

Una vez que creas un recurso de glosario, puedes usarlo para personalizar las traducciones del texto que envías a la API de Cloud Translation.

La siguiente función usa el recurso de glosario que se creó antes para personalizar la traducción del texto.

Python

def translate_text(
    text: str,
    source_language_code: str,
    target_language_code: str,
    project_id: str,
    glossary_name: str,
) -> str:
    """Translates text to a given language using a glossary

    Args:
    text: String of text to translate
    source_language_code: language of input text
    target_language_code: language of output text
    project_id: GCP project id
    glossary_name: name you gave your project's glossary
        resource when you created it

    Return:
    String of translated text
    """

    # Instantiates a client
    client = translate.TranslationServiceClient()

    # Designates the data center location that you want to use
    location = "us-central1"

    glossary = client.glossary_path(project_id, location, glossary_name)

    glossary_config = translate.TranslateTextGlossaryConfig(glossary=glossary)

    parent = f"projects/{project_id}/locations/{location}"

    result = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": source_language_code,
            "target_language_code": target_language_code,
            "glossary_config": glossary_config,
        }
    )

    # Extract translated text from API response
    return result.glossary_translations[0].translated_text

Node.js

/**
 * Translates text to a given language using a glossary
 *
 * ARGS
 * text: String of text to translate
 * sourceLanguageCode: language of input text
 * targetLanguageCode: language of output text
 * projectId: GCP project id
 * glossaryName: name you gave your project's glossary
 *     resource when you created it
 * RETURNS
 * String of translated text
 **/
async function translateText(
  text,
  sourceLanguageCode,
  targetLanguageCode,
  projectId,
  glossaryName
) {
  // Instantiates a client
  const translationClient = new translate.TranslationServiceClient();
  const glossary = translationClient.glossaryPath(
    projectId,
    'us-central1',
    glossaryName
  );
  const glossaryConfig = {
    glossary: glossary,
  };
  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, 'us-central1'),
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: sourceLanguageCode,
    targetLanguageCode: targetLanguageCode,
    glossaryConfig: glossaryConfig,
  };

  // Run request
  const [response] = await translationClient.translateText(request);
  // Extract the string of translated text
  return response.glossaryTranslations[0].translatedText;
}

Usa Text-to-Speech con el lenguaje de marcación de síntesis de voz

Ahora que personalizaste la traducción de un texto detectado desde una imagen, estás listo para usar la API de Text-to-Speech. La API de Text-to-Speech puede crear audios sintéticos a partir del texto traducido.

La API de Text-to-Speech genera audios sintéticos a partir de una string de texto sin formato o una string de texto marcada con el lenguaje de marcación de síntesis de voz (SSML). El SSML es un lenguaje de marcación que admite anotaciones de texto con etiquetas de SSML. Puedes usar etiquetas SSML para influir en cómo la API de Text-to-Speech formatea la creación de voz sintética.

La siguiente función convierte una string de SSML en un archivo MP3 de voz sintética.

Python

def text_to_speech(text: str, outfile: str) -> str:
    """Converts plaintext to SSML and
    generates synthetic audio from SSML

    Args:

    text: text to synthesize
    outfile: filename to use to store synthetic audio

    Returns:
    String of synthesized audio
    """

    # Replace special characters with HTML Ampersand Character Codes
    # These Codes prevent the API from confusing text with
    # SSML commands
    # For example, '<' --> '&lt;' and '&' --> '&amp;'
    escaped_lines = html.escape(text)

    # Convert plaintext to SSML in order to wait two seconds
    #   between each line in synthetic speech
    ssml = "<speak>{}</speak>".format(
        escaped_lines.replace("\n", '\n<break time="2s"/>')
    )

    # Instantiates a client
    client = texttospeech.TextToSpeechClient()

    # Sets the text input to be synthesized
    synthesis_input = texttospeech.SynthesisInput(ssml=ssml)

    # Builds the voice request, selects the language code ("en-US") and
    # the SSML voice gender ("MALE")
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US", ssml_gender=texttospeech.SsmlVoiceGender.MALE
    )

    # Selects the type of audio file to return
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Performs the text-to-speech request on the text input with the selected
    # voice parameters and audio file type

    request = texttospeech.SynthesizeSpeechRequest(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    response = client.synthesize_speech(request=request)

    # Writes the synthetic audio to the output file.
    with open(outfile, "wb") as out:
        out.write(response.audio_content)
        print("Audio content written to file " + outfile)

Node.js

/**
 * Generates synthetic audio from plaintext tagged with SSML.
 *
 * Given the name of a text file and an output file name, this function
 * tags the text in the text file with SSML. This function then
 * calls the Text-to-Speech API. The API returns a synthetic audio
 * version of the text, formatted according to the SSML commands. This
 * function saves the synthetic audio to the designated output file.
 *
 * ARGS
 * text: String of plaintext
 * outFile: String name of file under which to save audio output
 * RETURNS
 * nothing
 *
 */
async function syntheticAudio(text, outFile) {
  // Replace special characters with HTML Ampersand Character Codes
  // These codes prevent the API from confusing text with SSML tags
  // For example, '<' --> '&lt;' and '&' --> '&amp;'
  let escapedLines = text.replace(/&/g, '&amp;');
  escapedLines = escapedLines.replace(/"/g, '&quot;');
  escapedLines = escapedLines.replace(/</g, '&lt;');
  escapedLines = escapedLines.replace(/>/g, '&gt;');

  // Convert plaintext to SSML
  // Tag SSML so that there is a 2 second pause between each address
  const expandedNewline = escapedLines.replace(/\n/g, '\n<break time="2s"/>');
  const ssmlText = '<speak>' + expandedNewline + '</speak>';

  // Creates a client
  const client = new textToSpeech.TextToSpeechClient();

  // Constructs the request
  const request = {
    // Select the text to synthesize
    input: {ssml: ssmlText},
    // Select the language and SSML Voice Gender (optional)
    voice: {languageCode: 'en-US', ssmlGender: 'MALE'},
    // Select the type of audio encoding
    audioConfig: {audioEncoding: 'MP3'},
  };

  // Performs the Text-to-Speech request
  const [response] = await client.synthesizeSpeech(request);
  // Write the binary audio content to a local file
  const writeFile = util.promisify(fs.writeFile);
  await writeFile(outFile, response.audioContent, 'binary');
  console.log('Audio content written to file ' + outFile);
}

Revisión general

En los pasos anteriores, definiste las funciones en hybrid_glossaries.py que usan Vision, Translation y Text-to-Speech. Ya estás listo para usar estas funciones a fin de generar la voz sintética para el texto traducido de la siguiente foto.

El siguiente código llama a las funciones definidas en hybrid_glossaries.py para lo siguiente:

crear un recurso de glosario de la API de Cloud Translation
usar la API de Vision para detectar texto en la imagen anterior
realizar una traducción del glosario de la API de Cloud Translation del texto detectado
generar voz sintética del texto traducido en Text-to-Speech

Python

def main() -> None:
    """This method is called when the tutorial is run in the Google Cloud
    Translation API. It creates a glossary, translates text to
    French, and speaks the translated text.

    Args:
    None

    Returns:
    None
    """
    # Photo from which to extract text
    infile = "resources/example.png"
    # Name of file that will hold synthetic speech
    outfile = "resources/example.mp3"

    # Defines the languages in the glossary
    # This list must match the languages in the glossary
    #   Here, the glossary includes French and English
    glossary_langs = ["fr", "en"]
    # Name that will be assigned to your project's glossary resource
    glossary_name = "bistro-glossary"
    # uri of .csv file uploaded to Cloud Storage
    glossary_uri = "gs://cloud-samples-data/translation/bistro_glossary.csv"

    created_glossary_name = create_glossary(
        glossary_langs, PROJECT_ID, glossary_name, glossary_uri
    )

    # photo -> detected text
    text_to_translate = pic_to_text(infile)
    # detected text -> translated text
    text_to_speak = translate_text(
        text_to_translate, "fr", "en", PROJECT_ID, created_glossary_name
    )
    # translated text -> synthetic audio
    text_to_speech(text_to_speak, outfile)

Node.js

await createGlossary(glossaryLangs, projectId, glossaryName, glossaryUri);
const text = await picToText(inFile);
const translatedText = await translateText(
  text,
  'fr',
  'en',
  projectId,
  glossaryName
);
syntheticAudio(translatedText, outFile);

Ejecuta el código

Para ejecutar el código, ingresa el siguiente comando en la terminal del directorio en el que se encuentra tu código:

Python

python hybrid_tutorial.py

Node.js

  node hybridGlossaries.js

Aparece este resultado:

Created glossary bistro-glossary.
Audio content written to file resources/example.mp3

Después de ejecutar el código, navega hasta el directorio resources desde el directorio hybrid_glossaries. Busca un archivo example.mp3 en el directorio de recursos.

Escucha el siguiente clip de audio para comprobar que tu archivo example.mp3 suene igual.

Soluciona problemas de mensajes de error

```
403 IAM permission 'cloudtranslate.glossaries.create' denied.
```
Si usas una clave de cuenta de servicio sin los permisos de “editor de la API de Cloud Translation”, se genera esta excepción.
```
KeyError: 'GCLOUD_PROJECT'
```
Si no se establece la variable GCLOUD_PROJECT, se generará este error.
```
400 Invalid resource name project id
```
Si usas un nombre de glosario que contenga caracteres distintos de letras minúsculas, dígitos, puntos, dos puntos o guiones, o usas una clave de cuenta de servicio sin los permisos de “editor de la API de Cloud Translation” se genera esta excepción.
```
File filename was not found.
```
Si estableces la variable GOOGLE_APPLICATION_CREDENTIALS en una ruta de archivos no válida, se genera esta excepción.

Could not automatically determine credentials. Please set GOOGLE_APPLICATION_CREDENTIALS or explicitly create credentials and re-run the application

Si no configuras la variable GOOGLE_APPLICATION_CREDENTIALS, se genera esta excepción.

```
Forbidden: 403 POST API has not been used or is disabled
```
Si llamas a la API de Cloud Translation, a la API de Cloud Vision o a la API de Text-to-Speech sin habilitar sus API, se genera esta advertencia.
```
AttributeError: 'module' object has no attribute 'escape'
```
Python 2.7.10 o las versiones anteriores no son compatibles con HTML. Para corregir este error, usa un entorno virtual de Python. El entorno virtual usa la versión más reciente de Python.
```
UnicodeEncodeError
```
Python 2.7.10 o las versiones anteriores no son compatibles con HTML. Para corregir este error, usa un entorno virtual de Python. El entorno virtual usa la versión más reciente de Python.

Realice una limpieza

Usa la consola de Google Cloud para borrar tu proyecto si no lo necesitas. Si borras tu proyecto, no se aplicarán cargos adicionales a tu cuenta de Facturación de Cloud por los recursos que se usan en este instructivo.

Borre el proyecto

En la consola de Google Cloud, ve a la página Proyectos.
En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar.
En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.

Próximos pasos

Felicitaciones. Acabas de usar el OCR de Vision para detectar texto en una imagen. Luego, creaste un glosario en Translation y lo usaste para realizar una traducción. A continuación, usaste Text-to-Speech para generar un audio sintético del texto traducido.

Para aprovechar tus conocimientos de Visión, Translation y Text-to-Speech, haz lo siguiente:

Crea tu propio glosario. Obtén más información sobre cómo crear un depósito de Cloud Storage y subir tu archivo CSV del glosario al depósito.
Experimenta con otras formas de usar los glosarios de Translation.
Obtén más información sobre cómo usar Cloud Storage con el OCR de Cloud Vision.
Obtén más información sobre cómo usar el SSML con Text-to-Speech.
Obtén más información sobre cómo usar el campo imageContext de la API de Vision para transmitir contexto adicional sobre una foto cuando usas el OCR de Vision.
Explora los instructivos de la comunidad.