Esta página foi traduzida pela API Cloud Translation.

Traduzir texto de uma foto

Esta página mostra como detetar texto numa imagem, como personalizar traduções e como gerar voz sintética a partir de texto. Este tutorial usa o Cloud Vision para detetar texto num ficheiro de imagem. Em seguida, este tutorial mostra como usar o Cloud Translation para fornecer uma tradução personalizada do texto detetado. Por último, este tutorial usa a conversão de texto em voz para fornecer o ditado automático do texto traduzido.

Objetivos

Transmita texto reconhecido pela Cloud Vision API para a Cloud Translation API.
Crie e use glossários do Cloud Translation para personalizar as traduções da Cloud Translation API.
Crie uma representação de áudio do texto traduzido através da API Text-to-Speech.

Custos

Cada Google Cloud API usa uma estrutura de preços separada.

Para ver detalhes sobre os preços, consulte o guia de preços do Cloud Vision, o guia de preços do Cloud Translation e o guia de preços do Text-to-Speech.

Antes de começar

Certifique-se de que tem:

Um projeto na Google Cloud consola com a API Vision, a API Cloud Translation e a API Text-to-Speech ativadas
Familiaridade básica com a programação em Python ou NodeJS

Configurar bibliotecas de cliente

Este tutorial usa as bibliotecas de cliente Vision, Translation, e Text-to-Speech.

Para instalar as bibliotecas de cliente relevantes, execute os seguintes comandos a partir do terminal.

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

Configurar autorizações para a criação de glossários

A criação de glossários de tradução requer a utilização de uma chave de conta de serviço com autorizações de "Editor da Cloud Translation API".

Para configurar uma chave de conta de serviço com autorizações de editor da Cloud Translation API, faça o seguinte:

Crie uma conta de serviço:
1. Na Google Cloud consola, aceda à página Contas de serviço.
  
  Aceder a Contas de serviço
2. Selecione o seu projeto.
3. Clique em Criar conta de serviço.
4. No campo Nome da conta de serviço, introduza um nome. A Google Cloud consola preenche o campo ID da conta de serviço com base neste nome.
5. Opcional: no campo Descrição da conta de serviço, introduza uma descrição para a conta de serviço.
6. Clique em Criar e continuar.
7. Clique no campo Selecionar uma função e selecione Cloud Translation > Editor da API Cloud Translation
8. Clique em Concluído para terminar de criar a conta de serviço.
  
  Não feche a janela do navegador. Vai usá-lo no passo seguinte.
Transfira uma chave JSON para a conta de serviço que acabou de criar:
1. Na Google Cloud consola, clique no endereço de email da conta de serviço que criou.
2. Clique em Chaves.
3. Clique em Adicionar chave e, de seguida, em Criar nova chave.
4. Clique em Criar. É transferido um ficheiro de chave JSON para o seu computador.
  
  Certifique-se de que armazena o ficheiro de chave em segurança, uma vez que pode ser usado para autenticar como a sua conta de serviço. Pode mover e mudar o nome deste ficheiro como quiser.
5. Clique em Fechar.
No terminal, defina a variável GOOGLE_APPLICATION_CREDENTIALS com o seguinte comando. Substitua path_to_key pelo caminho para o ficheiro JSON transferido que contém a chave da nova conta de serviço.
Linux ou macOS
```
export GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```
Windows
```
set GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```

Importar bibliotecas

Este tutorial usa as seguintes importações do sistema e importações da biblioteca cliente.

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do Cloud Translation com bibliotecas cliente. Para mais informações, consulte a documentação de referência da PythonAPI Cloud Translation.

Para se autenticar no Cloud Translation, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento 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 experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Cloud Translation com bibliotecas cliente. Para mais informações, consulte a documentação de referência da Node.jsAPI Cloud Translation.

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

Definir o ID do projeto

Tem de associar um Google Cloud projeto a cada pedido a uma Google Cloud API. Designe o seu Google Cloud projeto definindo a variável de ambiente GCLOUD_PROJECT a partir do terminal.

No comando seguinte, substitua project-id pelo ID do seu Google Cloud projeto. Execute o seguinte comando a partir do terminal.

Linux ou macOS

export GCLOUD_PROJECT=project-id

Windows

set GCLOUD_PROJECT=project-id

Usar a API Vision para detetar texto a partir de uma imagem

Use a API Vision para detetar e extrair texto de uma imagem. A API Vision usa o reconhecimento ótico de carateres (OCR) para suportar duas funcionalidades de deteção de texto: deteção de texto denso ou DOCUMENT_TEXT_DETECTION, e deteção de texto esparso ou TEXT_DETECTION.

O código seguinte mostra como usar a funcionalidade DOCUMENT_TEXT_DETECTION da API Vision para detetar texto numa foto com 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;
}

Usar a tradução com glossários

Depois de extrair texto de uma imagem, use glossários de tradução para personalizar a tradução do texto extraído. Os glossários oferecem traduções predefinidas que substituem as traduções da Cloud Translation API de termos designados.

Os exemplos de utilização do glossário incluem:

Nomes dos produtos: por exemplo, "Google Home" tem de ser traduzido como "Google Home".
Palavras ambíguas: por exemplo, a palavra "morcego" pode significar um animal ou um objeto usado para praticar desporto. Se souber que está a traduzir palavras sobre desporto, pode querer usar um glossário para fornecer à API Cloud Translation a tradução desportiva de "bat" e não a tradução do animal.
Palavras emprestadas: por exemplo, "bouillabaisse" em francês traduz-se para "bouillabaisse" em inglês; a língua inglesa emprestou a palavra "bouillabaisse" à língua francesa. Um falante de inglês sem contexto cultural francês pode não saber que a bouillabaisse é um prato francês de guisado de peixe. Os glossários podem substituir uma tradução para que "bouillabaisse" em francês seja traduzido como "caldeirada de peixe" em inglês.

Criar um ficheiro de glossário

A API Cloud Translation aceita ficheiros de glossário TSV, CSV ou TMX. Este tutorial usa um ficheiro CSV carregado para o Cloud Storage para definir conjuntos de termos equivalentes.

Para criar um ficheiro CSV de glossário:

Designe o idioma de uma coluna através dos códigos de idioma ISO-639 ou BCP-47 na primeira linha do ficheiro CSV.
```
fr,en,
```
Liste pares de termos equivalentes em cada linha do ficheiro CSV. Separe os termos com vírgulas. O exemplo seguinte define a tradução para inglês de várias palavras francesas relacionadas com culinária.
```
fr,en,
chèvre,goat cheese,
crème brulée,crème brulée,
bouillabaisse,fish stew,
steak frites,steak with french fries,
```

Definir variantes de uma palavra. A API Cloud Translation é sensível a maiúsculas e minúsculas e a carateres especiais, como palavras com acentos. Certifique-se de que o glossário processa as variações de uma palavra definindo explicitamente as diferentes grafias da palavra.

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,

Carregue o glossário para um contentor do Cloud Storage. Para os fins deste tutorial, não tem de carregar um ficheiro de glossário para um contentor do Cloud Storage nem criar um contentor do Cloud Storage. Em alternativa, use o ficheiro de glossário disponível publicamente criado para este tutorial para evitar incorrer em custos do Cloud Storage. Envie o URI de um ficheiro de glossário no Cloud Storage para a Cloud Translation API para criar um recurso de glossário. O URI do ficheiro de glossário disponível publicamente para este tutorial é gs://cloud-samples-data/translation/bistro_glossary.csv. Para transferir o glossário, clique no link URI acima, mas não o abra num novo separador.

Criar um recurso de glossário

Para usar um glossário, tem de criar um recurso de glossário com a Cloud Translation API. Para criar um recurso de glossário, envie o URI de um ficheiro de glossário no Cloud Storage para a Cloud Translation API.

Certifique-se de que está a usar uma chave de conta de serviço com autorizações de "Editor da API Cloud Translation" e certifique-se de que definiu o ID do projeto a partir do terminal.

A função seguinte cria um recurso de glossário. Com este recurso de glossário, pode personalizar o pedido de tradução no passo seguinte deste 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.'
    );
  }
}

Tradução com glossários

Depois de criar um recurso de glossário, pode usá-lo para personalizar as traduções de texto que envia para a API Cloud Translation.

A função seguinte usa o recurso de glossário criado anteriormente para personalizar a tradução de 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;
}

Usar a conversão de texto em voz com a linguagem de marcação de síntese de voz

Agora que personalizou uma tradução de texto detetado em imagens, tem tudo pronto para usar a API Text-to-Speech. A API Text-to-Speech pode criar áudio sintético do seu texto traduzido.

A API Text-to-Speech gera áudio sintético a partir de uma string de texto simples ou uma string de texto marcado com Speech Synthesis Markup Language (SSML). O SSML é uma linguagem de marcação que suporta a anotação de texto com etiquetas SSML. Pode usar etiquetas SSML para influenciar a forma como a API Text-to-Speech formata a criação de voz sintética.

A seguinte função converte uma string de SSML num ficheiro 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);
}

A reunir tudo

Nos passos anteriores, definiu funções em hybrid_glossaries.py que usam o Vision, o Translation e o Text-to-Speech. Agora, está pronto para usar estas funções para gerar voz sintética do texto traduzido da seguinte foto.

O código seguinte chama funções definidas em hybrid_glossaries.py para:

criar um recurso de glossário da Cloud Translation API
usar a API Vision para detetar texto na imagem acima
realizar uma tradução de glossário da API Cloud Translation do texto detetado
gerar voz sintética de conversão de texto em voz do texto traduzido

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

Executar o código

Para executar o código, introduza o seguinte comando no terminal no diretório onde o código se encontra:

Python

python hybrid_tutorial.py

Node.js

  node hybridGlossaries.js

É apresentado o seguinte resultado:

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

Depois de executar o código, navegue para o diretório resources a partir do diretório hybrid_glossaries. Verifique se existe um ficheiro example.mp3 no diretório de recursos.

Ouça o seguinte clipe de áudio para verificar se o seu ficheiro example.mp3 tem o mesmo som.

Resolução de problemas de mensagens de erro

```
403 IAM permission 'cloudtranslate.glossaries.create' denied.
```
A utilização de uma chave de conta de serviço sem autorizações de "Editor da API Cloud Translation" gera esta exceção.
```
KeyError: 'GCLOUD_PROJECT'
```
Se não definir a variável GCLOUD_PROJECT, é gerado este erro.
```
400 Invalid resource name project id
```
A utilização de um nome de glossário que contenha carateres que não sejam letras minúsculas, dígitos, pontos finais, dois pontos ou hífenes, ou a utilização de uma chave de conta de serviço sem autorizações de "Editor da API Cloud Translation" gera esta exceção.
```
File filename was not found.
```
Definir a variável GOOGLE_APPLICATION_CREDENTIALS para um caminho de ficheiro inválido gera esta exceção.

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

Não definir a variável GOOGLE_APPLICATION_CREDENTIALS gera esta exceção.

```
Forbidden: 403 POST API has not been used or is disabled
```
A chamada da API Cloud Translation, da API Cloud Vision ou da API Text-to-Speech sem ativar as respetivas APIs gera este aviso.
```
AttributeError: 'module' object has no attribute 'escape'
```
O Python 2.7.10 ou anterior não é compatível com o HTML. Para corrigir este erro, use um ambiente virtual do Python. O ambiente virtual vai usar a versão mais recente do Python.
```
UnicodeEncodeError
```
O Python 2.7.10 ou anterior não é compatível com o HTML. Para corrigir este erro, use um ambiente virtual do Python. O ambiente virtual vai usar a versão mais recente do Python.

Limpar

Use a Google Cloud consola para eliminar o seu projeto se não precisar dele. A eliminação do projeto impede a incorrência de encargos adicionais na sua conta do Cloud Billing pelos recursos usados neste tutorial.

Eliminar o projeto

Na Google Cloud consola, aceda à página Projetos.
Na lista de projetos, selecione o projeto que quer eliminar e clique em Eliminar.
Na caixa de diálogo, escreva o ID do projeto e clique em Encerrar para eliminar o projeto.

O que se segue?

Parabéns! Acabou de usar o OCR da API Vision para detetar texto numa imagem. Em seguida, criou um glossário de tradução e fez uma tradução com esse glossário. Posteriormente, usou a tecnologia de conversão de texto em voz para gerar áudio sintético do texto traduzido.

Para desenvolver os seus conhecimentos sobre o Vision, a Tradução e a Síntese de voz:

Crie o seu próprio glossário. Saiba como criar um contentor do Cloud Storage e carregar o ficheiro CSV do glossário para o contentor.
Experimente outras formas de usar os glossários de tradução.
Saiba como usar o Cloud Storage com o OCR do Cloud Vision.
Saiba como usar SSML com a funcionalidade de conversão de texto em voz.
Saiba como usar o campo imageContext da API Vision para transmitir contexto adicional sobre uma foto quando usar o OCR da Vision.
Explore tutoriais da comunidade.

Traduzir texto de uma foto Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Objetivos

Custos

Antes de começar

Configurar bibliotecas de cliente

Python

Node.js

Configurar autorizações para a criação de glossários

Linux ou macOS

Windows

Importar bibliotecas

Python

Node.js

Definir o ID do projeto

Linux ou macOS

Windows

Usar a API Vision para detetar texto a partir de uma imagem

Python

Node.js

Usar a tradução com glossários

Criar um ficheiro de glossário

Criar um recurso de glossário

Python

Node.js

Tradução com glossários

Python

Node.js

Usar a conversão de texto em voz com a linguagem de marcação de síntese de voz

Python

Node.js

A reunir tudo

Python

Node.js

Executar o código

Python

Node.js

Resolução de problemas de mensagens de erro

Limpar

Eliminar o projeto

O que se segue?

Traduzir texto de uma foto