Traduzione di testo da una foto

Questa pagina mostra come rilevare il testo in un'immagine, personalizzare le traduzioni e generare la sintesi vocale dal testo. Questo tutorial utilizza Cloud Vision per rilevare il testo in un file immagine. Successivamente, il tutorial mostra come utilizzare Cloud Translation per fornire una traduzione personalizzata del testo rilevato. Infine, il tutorial utilizza Text-to-Speech per fornire la dettatura automatica del testo tradotto.

Obiettivi

Passare il testo riconosciuto dall'API Cloud Vision all'API Cloud Translation.
Creare e utilizzare i glossari di Cloud Translation per personalizzare le traduzioni dell'API Cloud Translation.
Creare una rappresentazione audio del testo tradotto utilizzando l'API Text-to-Speech.

Costi

Ogni API Google Cloud utilizza una struttura dei prezzi separata.

Per informazioni dettagliate sui prezzi, consulta la guida ai prezzi di Cloud Vision, la guida ai prezzi di Cloud Translation e la guida ai prezzi di Text-to-Speech.

Prima di iniziare

Assicurati di avere:

Un progetto nella consoleGoogle Cloud con l'API Vision, l'API Cloud Translation e l'API Text-to-Speech abilitate
Una conoscenza di base della programmazione in Python o NodeJS

Configurazione delle librerie client

Questo tutorial utilizza le librerie client di Vision, Translation e Text-to-Speech.

Per installare le librerie client pertinenti, esegui questi comandi dal terminale.

Python

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

Node.js

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

Configurazione delle autorizzazioni per la creazione di glossari

La creazione di glossari per Translation richiede l'utilizzo di una chiave del service account con le autorizzazioni "Cloud Translation API Editor".

Per configurare una chiave del service account con le autorizzazioni come Cloud Translation API Editor, procedi nel seguente modo:

Crea un service account:
1. Nella console Google Cloud , vai alla pagina Service account.
  
  Vai a Service account
2. Seleziona il progetto.
3. Fai clic su Crea service account.
4. Nel campo Nome service account, inserisci un nome. La consoleGoogle Cloud compila il campo ID service account in base a questo nome.
5. (Facoltativo) Nel campo Descrizione service account, inserisci una descrizione del service account.
6. Fai clic su Crea e continua.
7. Fai clic sul campo Seleziona un ruolo e seleziona Cloud Translation > Cloud Translation API Editor.
8. Fai clic su Fine per completare la creazione del service account.
  
  Non chiudere la finestra del browser. Lo utilizzerai nel prossimo passaggio.
Scarica una chiave JSON per il service account che hai appena creato:
1. Nella console Google Cloud , fai clic sull'indirizzo email del service account che hai creato.
2. Fai clic su Chiavi.
3. Fai clic su Aggiungi chiave, poi su Crea nuova chiave.
4. Fai clic su Crea. Un file della chiave JSON viene scaricato sul computer.
  
  Assicurati di archiviare il file della chiave in modo sicuro, perché può essere utilizzato per l'autenticazione come service account. Puoi spostare e rinominare il file come preferisci.
5. Fai clic su Chiudi.
Nel terminale, imposta la variabile GOOGLE_APPLICATION_CREDENTIALS utilizzando il comando seguente. Sostituisci path_to_key con il percorso del file JSON scaricato contenente la chiave del nuovo service account.
Linux o macOS
```
export GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```
Windows
```
set GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```

Importazione delle librerie

Questo tutorial utilizza le seguenti importazioni di sistema e delle librerie client.

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Cloud Translation per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per eseguire l'autenticazione in Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Cloud Translation per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation 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');

Impostazione dell'ID progetto

Devi associare un progettoGoogle Cloud a ogni richiesta a un'API Google Cloud . Specifica il tuo progettoGoogle Cloud impostando la variabile di ambiente GCLOUD_PROJECT dal terminale.

Nel comando seguente, sostituisci project-id con il tuo ID progetto Google Cloud . Esegui questo comando dal terminale.

Linux o macOS

export GCLOUD_PROJECT=project-id

Windows

set GCLOUD_PROJECT=project-id

Utilizzo di Vision per rilevare il testo da un'immagine

Utilizza l'API Vision per rilevare ed estrarre il testo da un'immagine. L'API Vision utilizza il riconoscimento ottico dei caratteri (OCR) per supportare due funzionalità di rilevamento del testo: il rilevamento di testo denso, o DOCUMENT_TEXT_DETECTION, e il rilevamento di testo sparso, o TEXT_DETECTION.

Il codice seguente mostra come utilizzare la funzionalità DOCUMENT_TEXT_DETECTION dell'API Vision per rilevare il testo in una foto con testo 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;
}

Utilizzo di Translation con i glossari

Dopo aver estratto il testo da un'immagine, utilizza i glossari di Translation per personalizzare la traduzione del testo estratto. I glossari forniscono traduzioni predefinite che sostituiscono le traduzioni dell'API Cloud Translation dei termini designati.

I casi d'uso del glossario includono:

Nomi di prodotti: ad esempio, "Google Home" deve rimanere "Google Home".
Parole ambigue: ad esempio, la parola "pesca" può indicare un'attività o un frutto. Se sai che stai traducendo parole relative alla frutta, potresti voler utilizzare un glossario per fornire all'API Cloud Translation la traduzione relativa alla frutta "pesca", non quella relativa all'attività.
Prestiti: ad esempio, "bouillabaisse" in francese rimane "bouillabaisse" in italiano; la lingua italiana ha preso in prestito la parola "bouillabaisse" dalla lingua francese. Un italofono che non conosce il contesto culturale francese potrebbe non sapere che la bouillabaisse è un piatto francese a base di stufato di pesce. I glossari possono sostituire una traduzione in modo che "bouillabaisse" in francese venga tradotto come "zuppa di pesce" in italiano.

Creazione di un file di glossario

L'API Cloud Translation accetta file di glossario in formato TSV, CSV o TMX. Questo tutorial utilizza un file CSV caricato su Cloud Storage per definire insiemi di termini equivalenti.

Per creare un file CSV del glossario:

Specifica la lingua di una colonna utilizzando i codici lingua ISO-639 o BCP-47 nella prima riga del file CSV.
```
fr,en,
```
Elenca le coppie di termini equivalenti in ogni riga del file CSV. Separa i termini con le virgole. L'esempio seguente definisce la traduzione in inglese di diversi termini culinari francesi.
```
fr,en,
chèvre,goat cheese,
crème brulée,crème brulée,
bouillabaisse,fish stew,
steak frites,steak with french fries,
```

Definisci le varianti di una parola. L'API Cloud Translation è sensibile alle maiuscole e ai caratteri speciali come le parole accentate. Assicurati che il glossario gestisca le varianti di una parola definendo esplicitamente le diverse ortografie della parola.

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,

Carica il glossario in un bucket Cloud Storage. Ai fini di questo tutorial, non è necessario caricare un file di glossario in un bucket Cloud Storage né creare un bucket Cloud Storage. Utilizza invece il file di glossario disponibile pubblicamente creato per questo tutorial, per evitare di sostenere costi relativi a Cloud Storage. Invia l'URI di un file di glossario in Cloud Storage all'API Cloud Translation per creare una risorsa di glossario. L'URI del file di glossario disponibile pubblicamente per questo tutorial è gs://cloud-samples-data/translation/bistro_glossary.csv. Per scaricare il glossario, fai clic sul link URI riportato sopra, ma non aprirlo in una nuova scheda.

Creazione di una risorsa di glossario

Per utilizzare un glossario, devi creare una risorsa di glossario con l'API Cloud Translation. Per creare una risorsa di glossario, invia l'URI di un file di glossario in Cloud Storage all'API Cloud Translation.

Assicurati di utilizzare una chiave del service account con autorizzazioni "Cloud Translation API Editor" e di aver impostato l'ID progetto dal terminale.

La funzione seguente crea una risorsa di glossario. Con questa risorsa di glossario, puoi personalizzare la richiesta di traduzione nel passaggio successivo di questo tutorial.

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.'
    );
  }
}

Traduzione con i glossari

Una volta creata una risorsa di glossario, puoi utilizzarla per personalizzare le traduzioni del testo che invii all'API Cloud Translation.

La funzione seguente utilizza la risorsa di glossario creata in precedenza per personalizzare la traduzione del testo.

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;
}

Utilizzo di Text-to-Speech con Speech Synthesis Markup Language

Ora che hai personalizzato una traduzione del testo rilevato nell'immagine, puoi utilizzare l'API Text-to-Speech. L'API Text-to-Speech può creare audio sintetico del testo tradotto.

L'API Text-to-Speech genera audio sintetico da una stringa di testo normale o da una stringa di testo contrassegnata con Speech Synthesis Markup Language (SSML). SSML è un linguaggio di markup che supporta l'annotazione del testo con tag SSML. Puoi utilizzare i tag SSML per agire sul modo in cui l'API Text-to-Speech formatta la creazione della sintesi vocale.

La funzione seguente converte una stringa di SSML in un file MP3 di sintesi vocale.

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

In sintesi

Nei passaggi precedenti, hai definito le funzioni in hybrid_glossaries.py che utilizzano Vision, Translation e Text-to-Speech. Ora puoi utilizzare queste funzioni per generare la sintesi vocale del testo tradotto dalla seguente immagine.

Il codice seguente chiama le funzioni definite in hybrid_glossaries.py per:

Creare una risorsa di glossario dell'API Cloud Translation
Utilizzare l'API Vision per rilevare il testo nell'immagine mostrata sopra
Eseguire una traduzione con glossario del testo rilevato tramite l'API Cloud Translation
Generare la sintesi vocale del testo tradotto con 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);

Esecuzione del codice

Per eseguire il codice, inserisci il comando seguente nel terminale nella directory in cui si trova il codice:

Python

python hybrid_tutorial.py

Node.js

  node hybridGlossaries.js

Viene visualizzato il seguente output:

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

Dopo aver eseguito il codice, vai alla directory resources dalla directory hybrid_glossaries. Controlla la directory delle risorse per verificare che ci sia un file example.mp3.

Ascolta l'audio clip seguente per verificare che il tuo file example.mp3 sia identico.

Risoluzione dei messaggi di errore

```
403 IAM permission 'cloudtranslate.glossaries.create' denied.
```
L'utilizzo di una chiave del service account senza autorizzazioni "Cloud Translation API Editor" genera questa eccezione.
```
KeyError: 'GCLOUD_PROJECT'
```
Questo errore si verifica se non imposti la variabile GCLOUD_PROJECT.
```
400 Invalid resource name project id
```
Questa eccezione si verifica se utilizzi un nome di glossario che contiene caratteri diversi da lettere minuscole, numeri, punti, due punti o trattini oppure se utilizzi una chiave del service account senza autorizzazioni "Cloud Translation API Editor".
```
File filename was not found.
```
L'impostazione della variabile GOOGLE_APPLICATION_CREDENTIALS su un percorso file non valido genera questa eccezione.

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

Questa eccezione si verifica se non imposti la variabile GOOGLE_APPLICATION_CREDENTIALS.

```
Forbidden: 403 POST API has not been used or is disabled
```
Questo avviso viene generato se l'API Cloud Translation, l'API Cloud Vision o l'API Text-to-Speech vengono chiamate senza abilitare le API.
```
AttributeError: 'module' object has no attribute 'escape'
```
Python 2.7.10 o versioni precedenti non è compatibile con HTML. Per risolvere questo errore, utilizza un ambiente virtuale Python. L'ambiente virtuale utilizzerà la versione più recente di Python.
```
UnicodeEncodeError
```
Python 2.7.10 o versioni precedenti non è compatibile con HTML. Per risolvere questo errore, utilizza un ambiente virtuale Python. L'ambiente virtuale utilizzerà la versione più recente di Python.

Pulizia

Utilizza la consoleGoogle Cloud per eliminare il progetto se non ti serve. L'eliminazione del progetto impedisce l'addebito di costi aggiuntivi al tuo account di fatturazione Cloud per le risorse utilizzate in questo tutorial.

Eliminazione del progetto

Nella consoleGoogle Cloud , vai alla pagina Progetti.
Nell'elenco dei progetti, seleziona quello da eliminare e fai clic su Elimina.
Nella finestra di dialogo, digita l'ID progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Complimenti! Hai appena utilizzato l'OCR di Vision per rilevare il testo in un'immagine. Poi hai creato un glossario di traduzione e hai eseguito una traduzione con quel glossario. Successivamente, hai utilizzato Text-to-Speech per generare l'audio sintetico del testo tradotto.

Per approfondire le tue conoscenze di Vision, Translation e Text-to-Speech:

Crea il tuo glossario. Scopri come creare un bucket Cloud Storage e come caricare il file CSV del glossario nel bucket.
Sperimenta altri modi per utilizzare i glossari di Translation.
Scopri come utilizzare Cloud Storage con l'OCR di Cloud Vision.
Scopri di più su come utilizzare SSML con Text-to-Speech.
Scopri come utilizzare il campo imageContext dell'API Vision per trasmettere un contesto aggiuntivo relativo a una foto quando utilizzi l'OCR di Vision.
Esplora i tutorial della community.

Traduzione di testo da una foto Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Configurazione delle librerie client

Python

Node.js

Configurazione delle autorizzazioni per la creazione di glossari

Linux o macOS

Windows

Importazione delle librerie

Python

Node.js

Impostazione dell'ID progetto

Linux o macOS

Windows

Utilizzo di Vision per rilevare il testo da un'immagine

Python

Node.js

Utilizzo di Translation con i glossari

Creazione di un file di glossario

Creazione di una risorsa di glossario

Python

Node.js

Traduzione con i glossari

Python

Node.js

Utilizzo di Text-to-Speech con Speech Synthesis Markup Language

Python

Node.js

In sintesi

Python

Node.js

Esecuzione del codice

Python

Node.js

Risoluzione dei messaggi di errore

Pulizia

Eliminazione del progetto

Passaggi successivi

Traduzione di testo da una foto